NeoHorse-1 – TokenRhythm Collaborates with Wuwenxinqiong and Others to Launch Open-Source Agent Model

1. What is NeoHorse-1

NeoHorse-1 is an open-source Agent model series jointly developed by TokenRhythm, Wuwenxinqiong, Tsinghua University, Peking University, The Chinese University of Hong Kong, and Alibaba. It includes two parameter versions: 4B and 9B. This model employs an Agent-Native post-training paradigm, using real execution traces from the Routing Harness as training data. It reuses routing signals as a basis for course sorting during training, establishing a closed-loop mechanism between evaluation feedback, data distribution, and model updates. NeoHorse-1 covers four core capabilities: tool calling, task planning, deep search, and code generation. The 9B version achieved an average score of 69.04 across ten benchmark tests, surpassing the base model by 3.44 points. It natively supports a context window of up to 262,144 tokens and enables local deployment.

Technical Positioning and Domain: It belongs to the intersection of natural language processing and Agent systems, focusing on enhancing the task completion capabilities of language models in real execution environments. Unlike general-purpose conversational models, NeoHorse-1 is designed as an Agent execution engine, intended to be embedded within Agent orchestration frameworks such as Routing Harness. It assumes specific execution roles, including decision-making for tool calling, task decomposition and planning, multi-round retrieval integration, and code generation and debugging.

Development Background: Led by TokenRhythm, this model was co-developed with Wuwenxinqiong, Tsinghua University, Peking University, The Chinese University of Hong Kong, and Alibaba. The motivation for development stemmed from the prevalent "heavy on dialogue, light on execution" issue in current open-source models for Agent scenarios. Traditional post-training methods optimize models using question-answer corpora to enhance their expression capabilities, but they offer limited improvements in execution-level abilities such as tool calling failure recovery and multi-step task planning. The team chose to start from real execution traces to explore an Agent-native training path.

Core Value: NeoHorse-1 addresses the reliability challenges of open-source models in Agent execution tasks. While traditional models perform well in single-round dialogues after general post-training, they frequently fail in scenarios involving multi-round tool calling, environmental feedback processing, and error recovery. By incorporating real execution traces from the Router into the training data, NeoHorse-1 enables the model to directly learn task completion paths, including error identification and recovery strategies from failure cases, significantly improving key execution metrics such as tool calling accuracy, multi-step planning success rate, and code generation pass rate.

Technical Features: The core innovation lies in the use of structured execution traces from the Routing Harness as training data, rather than manually constructed question-answer corpora. These traces include five elements: request, routing, tool calling, environmental feedback, and error recovery, adding three cognitive dimensions—capability requirements, execution decisions, and environmental outcomes—to the traditional data set. Meanwhile, the C0–C3 capability signals from the router are converted offline into course sorting and data distribution criteria, forming a self-updating training loop. The model natively supports a long context window of up to 260,000 tokens and is compatible with mainstream inference frameworks such as SGLang and vLLM.

2. Key Features

• Tool Calling: The model autonomously selects and invokes external tools based on task requirements to complete multi-step operations. It scores 67.43 on the BFCL v4 function calling benchmark, outperforming the comparison model by 2.55 points. Its underlying mechanism treats tool selection as a sequence decision problem, leveraging real routing signals from the Harness trajectory during training to enable the model to understand the functional boundaries and invocation conditions of tools.

• Task Planning: Breaks down complex tasks into executable sub-steps and performs long-range planning and scheduling. It scores 48.73 on the QwenClawBench benchmark. This capability is built upon the learning of multi-step execution trajectories during Agent-Native training, allowing the model to dynamically adjust subsequent steps based on intermediate results, rather than mechanically executing predefined processes.

• Deep Search: Proactively retrieves and integrates information during multi-round interactions, supporting the construction of evidence chains for conclusions. The model natively supports a context window of 262,144 tokens, which can accommodate dozens of rounds of search history and returned results in a single task. It leverages the long context advantage to cross-verify fragmented information, making it suitable for evidence-intensive tasks such as research and report generation.

• Code Generation: Generates usable code and debugs and fixes it based on environmental feedback until the task is completed. It scores 98.17 on the HumanEval benchmark, surpassing the comparison model by 5.49 points. The training data retains failure trajectories and error recovery records, enabling the model to identify environmental feedback such as compilation errors and runtime exceptions and perform targeted corrections.

• Failure Trajectory Learning: The training set retains both successful and replaced failure records, allowing the model to learn the ability to "identify where errors are likely to occur and how to recover from them after errors happen." This is an important feature of Agent-Native training, enabling the model to demonstrate stronger fault tolerance in real execution environments, rather than just performing well under ideal input conditions.

• Ultra-Long Context Handling: Natively supports a context length of 262,144 tokens, and can be expanded to approximately 1,010,000 tokens when sufficient GPU memory is available. This capability is suitable for long-range Agent tasks, such as multi-round tool interactions lasting several hours or research workflows that accumulate a large amount of intermediate results.

• Multi-Framework Service Deployment: Compatible with the two major mainstream inference frameworks, SGLang and vLLM, and supports integration via the OpenAI SDK protocol, allowing developers to seamlessly incorporate local services into existing application pipelines. It also supports lightweight tools such as Ollama, reducing the deployment barriers for individual developers.

3. How to Use

1. Environment Requirements: Requires Linux or Windows operating system. It is recommended that GPU memory be no less than 16GB (for the 4B version) or 24GB (for the 9B version). The actual usable context length depends on the GPU memory capacity; if the memory is insufficient, reduce the context length first before deployment. It is recommended to use an NVIDIA GPU environment with CUDA 11.8 or higher.

2. Install Download Tool: Execute pip install -U modelscope to install the ModelScope command-line tool, which is used to pull model weights from the ModelScope platform. This tool supports resuming interrupted downloads and multi-threaded downloads, making it suitable for large file transfer scenarios.

3. Download the Model: Run modelscope download --model TokenRhythm/NeoHorse-1-9B --local_dir ./NeoHorse-1-9B to pull the 9B version weights. For the 4B version, simply replace the model name with TokenRhythm/NeoHorse-1-4B. After downloading, verify the file integrity to ensure that the weight files and configuration directory structure are consistent.

4. Deploy the Service: It is recommended to use SGLang to launch the inference service. The installation command is pip install "sglang==0.5.17". When launching, configure three key parameters: --context-length 262144 to specify the context window length, --reasoning-parser qwen3 to enable reasoning process parsing, and --tool-call-parser qwen3_coder to enable tool calling parsing. Alternatively, vLLM can be used as a substitute inference engine, but you will need to handle the corresponding parameter mapping yourself.

5. API Calling: After the service is started, point the base_url in the OpenAI SDK to the local service address (e.g., http://localhost:8000/v1), and you can send requests as if calling the OpenAI API. This compatibility layer allows developers to reuse existing OpenAI SDK code without additional learning costs.

6. Best Practices: In Agent tasks, it is recommended to use orchestration frameworks such as Routing Harness or OpenClaw. Embed NeoHorse-1 as the execution model within these frameworks to leverage its capabilities in tool calling and long-term planning. For deployment environments with limited resources, prioritize the 4B version, as its Agent performance has surpassed several larger-parameter general-purpose models.

4. Pros and Cons Analysis

5. Comparative Analysis with Similar Tools

Selection Recommendation: If the core requirement is to build a highly reliable Agent execution pipeline, such as for automated workflows, multi-tool orchestration, or deep research assistants, NeoHorse-1-9B is currently the most suitable open-source model for this scenario. Its tool calling accuracy (BFCL v4 67.43) and code generation pass rate (HumanEval 98.17) stand out among models of similar size. For development teams already relying on the Qwen technology stack and needing to maintain ecosystem compatibility, Qwen3.5-9B serves as a balanced choice, though they will need to address tool calling stability issues in long-range tasks themselves. In scenarios with limited deployment resources and a focus on conversational interaction, Qwen3-8B or GLM-4-9B remain viable options.

6. Editor's Summary

NeoHorse-1 has demonstrated a differentiated technical approach in the open-source Agent model space. Its core innovation lies in using the actual execution trajectory of the Routing Harness as the primary data source for training, shifting the model's optimization objective directly from "generating grammatically and semantically correct text" to "completing tasks." This design has yielded quantifiable performance improvements in benchmark tests: an average score of 3.44 points higher than the base model across ten items, a HumanEval score of 98.17, and a tau²-Bench score of 90.82, showcasing solid performance in two typical Agent scenarios—code generation and multi-turn human-machine tool interaction. Retaining decision-making data from failed trajectories in the training data is also technically sound, enabling the model to learn error pattern recognition and recovery strategies, a cognitive dimension that traditional question-answer datasets struggle to provide.

In terms of practical value, NeoHorse-1's native long-context support of 262,144 tokens, combined with the Apache-2.0 open-source license, offers dual configurations that meet the historical information retention needs of long-running Agent tasks while reducing legal barriers for commercial integration. Its compatibility with both SGLang and vLLM frameworks makes the deployment path relatively clear, and the OpenAI SDK compatibility layer further lowers the cost of API integration. Suitable adopters include: automation platform developers who need to build highly reliable tool calling pipelines, research tool development teams requiring deep long-context search capabilities, and data-sensitive organizations wishing to deploy Agent execution models in local environments.

Looking ahead, the Agent-Native training paradigm is still in its early stages. The current iteration has only validated the effectiveness of a single closed-loop, and signal and reward design still rely on manual configuration. Once the recursive self-improvement mechanism completes multi-round closed-loop validation, the model's autonomous evolution capabilities are expected to bring further improvements. It is recommended to follow future releases of this project and the disclosure of training details, especially the specific definitions of the six-dimensional quality evaluation criteria and the C0–C3 tiered rules.

7. Application Scenarios

• Agent Task Execution: Acts as an execution model within Harness frameworks such as OpenClaw, automatically completing real computer tasks like file operations and software usage, and autonomously recovering from failures. It scored 48.73 on the QwenClawBench test, outperforming the comparison model by 4.69 points, making it suitable for building computer operation automation agents.

• Tool Calling and API Orchestration: Automatically selects, combines, and invokes external APIs in multi-tool environments to build automated workflow assistants. A BFCL v4 score of 67.43 indicates a high level of function calling accuracy, making it appropriate for enterprise-level automation scenarios that require integration with multiple services, such as order processing, data synchronization, and system integration.

• Deep Search and Research Assistant: Performs multi-round active retrieval and cross-verification of information, providing evidence chains to support the generation of research reports with citations. With a context window of 260,000 tokens, it can accommodate dozens of rounds of search history and returned original texts, making it ideal for information-intensive tasks such as industry research, academic literature reviews, and competitive analysis.

• Enterprise Office Automation: Handles long-range, multi-step tasks such as schedule adjustments, data organization, and report generation in multi-domain workplace scenarios like WorkBuddy Bench. The model's task planning and code generation capabilities complement each other, covering the complete workflow from data extraction to visual presentation.

8. FAQ

Q: What GPU memory is required to deploy NeoHorse-1?
A: The 4B version is recommended to be deployed with at least 16GB GPU memory, while the 9B version requires at least 24GB. The actual usable context length is directly related to GPU memory. A full 262,144 token window requires a higher GPU memory configuration. If GPU memory is insufficient, you can first reduce the context length before deployment, such as gradually adjusting from 262,144 to 32,768 tokens.

Q: Which inference frameworks are supported?
A: The official recommendation includes SGLang (version 0.5.17) and vLLM. Both require configuration with the parameters --context-length 262144, --reasoning-parser qwen3, and --tool-call-parser qwen3_coder. Additionally, lightweight tools such as Ollama are supported. Developers can choose based on deployment environment and performance requirements.

Q: What are the differences between the 4B and 9B versions, and how should one choose?
A: Both versions are trained in an Agent-Native manner and share the same core capability structure. The 9B version performs better in benchmark tests (average score of 69.04 across ten items), but requires more GPU memory. The 4B version remains a viable option in resource-constrained environments, and its Agent performance has surpassed several larger-parameter general-purpose models. Prioritize the 9B version when conditions allow, and choose the 4B version if deployment space is limited.

Q: How can the context length be extended from 262,144 tokens to approximately 1.01 million tokens?
A: You need to enable the extended configuration in the inference framework and ensure sufficient GPU memory is available. The actual extension capability is constrained by hardware conditions, and feasible values must be determined through memory testing. The official recommendation is to first reduce the context length to complete deployment verification, then gradually increase it.

Q: Is commercial use of the model supported?
A: Yes. The project uses the Apache-2.0 open-source license, which allows for commercial use, modification, and redistribution without additional licensing fees. The original copyright notice and modification records must be retained.

Q: How are failed trajectories handled in the training data?
A: Failed trajectories are also included in the training set after structural checks and a six-dimensional quality assessment, together with successful trajectories to form the training corpus. By learning failure patterns, the model gains the ability to understand "where errors are likely to occur and how to recover after an error," which is a crucial training foundation for its fault tolerance in real execution environments.

9. Project Links

• GitHub Repository: https://github.com/TokenRhythm/NeoHorse
• Hugging Face Model Library: https://huggingface.co/collections/TokenRhythm/neohorse-1
• arXiv Technical Paper: https://arxiv.org/pdf/2609.08183