# AI use cases for Neo Horse (TokenRhythm/NeoHorse)

Repo: [TokenRhythm/NeoHorse](https://github.com/TokenRhythm/NeoHorse) | Use cases: 4 | Page: https://dedupedai.com/use-cases/tokenrhythm-neohorse/

NeoHorse is an open-weight model family from TokenRhythm for agent workflows, with 4B and 9B text models for tool use, coding, and instruction following, plus a 4B decision model called NeoHorse-Jev.

This file holds every use case of this repo. Each one starts with a "## " heading and ends with its URL.

- Serve NeoHorse-1 locally for agent tool calls: https://dedupedai.com/use-cases/tokenrhythm-neohorse/serve-neohorse-1-as-local-agent-model/
- Route requests with NeoHorse-Jev structured decisions: https://dedupedai.com/use-cases/tokenrhythm-neohorse/route-requests-with-neohorse-jev-decisions/
- Run a quantized NeoHorse-1 on your own hardware: https://dedupedai.com/use-cases/tokenrhythm-neohorse/run-quantized-neohorse-1-on-small-hardware/
- Rerun NeoHorse-1 with the reported sampling settings: https://dedupedai.com/use-cases/tokenrhythm-neohorse/rerun-neohorse-1-eval-sampling-protocol/

## How to serve NeoHorse-1 locally for agent tool calls with Neo Horse

Repo: [TokenRhythm/NeoHorse](https://github.com/TokenRhythm/NeoHorse) | Difficulty: Intermediate | Time: 1 hour | Basis: From the README

Host NeoHorse-1-4B on your own GPU with vLLM and send it chat requests from a local script.

**Who it is for:** A developer building a text-based agent harness who needs a self-hosted model that supports tool use and coding tasks.

**The problem:** Hosted model APIs may not fit a project that needs local control over the model and its serving settings.

**The outcome:** A running local endpoint at http://127.0.0.1:8000 that answers chat requests under the served name neohorse-1-4B.

### Steps

1. Download NeoHorse-1-4B from Hugging Face or ModelScope to a local directory that contains config.json, tokenizer files, and weights.
2. Run `pip install -U vllm`
3. Set MODEL_PATH to that directory, then run `vllm serve "$MODEL_PATH" --served-model-name neohorse-1-4B --host 0.0.0.0 --port 8000 --max-model-len 262144 --reasoning-parser qwen3 --enable-auto-tool-choice --tool-call-parser qwen3_coder` (inferred, check the README)
4. Run `pip install requests`
5. Run the chat example in the README's Send a Request section against http://127.0.0.1:8000 and check that it returns a reply.

### Prompt to paste into your agent

```text
In the TokenRhythm/NeoHorse repo, follow the vLLM steps in the Deployment section to serve the NeoHorse-1-4B checkpoint at <model-directory> on port 8000 with served name neohorse-1-4B. Return the chat reply text for the prompt <test-prompt>. Verify that the server log shows the model loaded without errors before sending the request.
```

### Caveat

The README says the 262,144-token setting is a configured limit and actual capacity depends on GPU memory, so you may need to lower --max-model-len.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/tokenrhythm-neohorse/serve-neohorse-1-as-local-agent-model/

## How to route requests with NeoHorse-Jev structured decisions with Neo Horse

Repo: [TokenRhythm/NeoHorse](https://github.com/TokenRhythm/NeoHorse) | Difficulty: Advanced | Time: 2 hours | Basis: From the README

Use NeoHorse-Jev-4B to pick an action, check a condition, or assign a rating from app state.

**Who it is for:** An application engineer whose workflow must choose between tools, branches, or request routes based on current state.

**The problem:** Hand-written routing rules become hard to maintain when the choice depends on free-form context.

**The outcome:** Your app gets a structured decision with probabilities from Choice, Noul, or Score and uses it to route requests or select tools.

### Steps

1. Download the complete NeoHorse-Jev-4B model bundle from Hugging Face or ModelScope, not only the weights.
2. Open jev/README.md in the repo and read the Deployment section.
3. Pick vLLM, SGLang, or the native Python runtime as described in that guide.
4. Write your questions and possible answers for Choice, Noul, or Score, and map each answer to a route or tool.
5. Run a few sample application states through the model and confirm the returned decision matches the route you expect.

### Prompt to paste into your agent

```text
In the TokenRhythm/NeoHorse repo, read the NeoHorse-Jev deployment guide in jev/README.md and set up the model bundle at <model-directory>. Send the application state <sample-state> with the Choice question <question> and report the selected answer and its probability. Verify that the probabilities for the listed answers sum to a value you can explain.
```

### Caveat

The README says the decision model needs its complete bundle and a matching runtime or backend adapter, and the deployment steps are in a separate jev/README.md that is not shown here.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/tokenrhythm-neohorse/route-requests-with-neohorse-jev-decisions/

## How to run a quantized NeoHorse-1 on your own hardware with Neo Horse

Repo: [TokenRhythm/NeoHorse](https://github.com/TokenRhythm/NeoHorse) | Difficulty: Intermediate | Time: 1 hour | Basis: From the README

Download a GGUF or MLX build of NeoHorse-1 that uses less memory than BF16 weights.

**Who it is for:** A developer or hobbyist with a laptop or modest GPU who wants to try NeoHorse-1 without a large server.

**The problem:** Full BF16 weights take more disk and memory than a personal machine can spare.

**The outcome:** A smaller NeoHorse-1 checkpoint running on local hardware, with the quantization level chosen to fit memory limits.

### Steps

1. Open the NeoHorse-1-4B-GGUF or NeoHorse-1-9B-GGUF page on Hugging Face.
2. Choose the 8-bit, 5-bit, or 4-bit file if you need less space, or the 16-bit BF16 file for full precision.
3. On Apple silicon, use the MLX versions from the NeoHorse-1 MLX collection on Hugging Face.
4. Follow the deployment instructions on that model card for the runtime you choose.
5. Send one short prompt and confirm the reply is coherent before running longer tasks.

### Prompt to paste into your agent

```text
In the TokenRhythm/NeoHorse repo, find the GGUF build of NeoHorse-1-4B on Hugging Face at <model-page> and pick the 4-bit quantized file. Follow that model card's deployment instructions and return the model's reply to the prompt <test-prompt>. Verify that the file size of the chosen build is smaller than the 16-bit BF16 build.
```

### Caveat

The README names GGUF and MLX builds but does not say which runtime to use with them, so check each model card before choosing one.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/tokenrhythm-neohorse/run-quantized-neohorse-1-on-small-hardware/

## How to rerun NeoHorse-1 with the reported sampling settings with Neo Horse

Repo: [TokenRhythm/NeoHorse](https://github.com/TokenRhythm/NeoHorse) | Difficulty: Advanced | Time: 2 hours | Basis: From the README

Serve a NeoHorse-1 checkpoint with the exact SGLang settings listed for the technical report.

**Who it is for:** A researcher or evaluator who wants to check NeoHorse-1 numbers against the reported protocol before comparing it with other models.

**The problem:** Benchmark scores change with sampling settings, so a comparison is only fair if the same settings are used.

**The outcome:** A local SGLang server that matches the reported protocol settings, ready for your own benchmark runs.

### Steps

1. Run `pip install "sglang==0.5.17"`
2. Set MODEL_PATH to the NeoHorse-1-9B directory, then run `python3 -m sglang.launch_server --model-path "$MODEL_PATH" --served-model-name neohorse-1-9B --host 0.0.0.0 --port 30000 --context-length 262144 --reasoning-parser qwen3 --tool-call-parser qwen3_coder` (inferred, check the README)
3. Set the client to temperature=1.0, top_p=0.95, top_k=20, min_p=0.0, presence_penalty=1.5, repetition_penalty=1.0.
4. Turn on thinking mode with enable_thinking=true and force_nonempty_content=true.
5. Run your chosen benchmark tasks and record the runs, noting that the README uses three runs for some benchmarks and one run for others.

### Prompt to paste into your agent

```text
In the TokenRhythm/NeoHorse repo, serve the NeoHorse-1-9B checkpoint at <model-directory> with SGLang v0.5.17 on port 30000 using the reported protocol settings in the Evaluation section. Send the benchmark prompt <benchmark-item> and return the answer and the settings used. Verify that the request sets temperature=1.0, top_p=0.95, and top_k=20 before recording any score.
```

### Caveat

The README gives the sampling settings but not the benchmark datasets or scripts, so you must obtain the official protocols yourself to reproduce the reported scores.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/tokenrhythm-neohorse/rerun-neohorse-1-eval-sampling-protocol/