Why wayfinder-qwen and not wayfinder-glimmer
The Wayfinder hackathon results and demo use wayfinder-qwen (Qwen3.6-35B-A3B) instead of wayfinder-glimmer (Muse Glimmer 30B), the first model trained with this recipe. Glimmer has the higher own-list recall on the 200 held-out tasks (0.452 against 0.415, paired difference for qwen -0.036), and the two are level on the coding pass rate (0.868 each, 34 tasks). Qwen was chosen for serving economics and for the cascade:
- It is a mixture of experts with about 3B active parameters, against a dense 30B, so a search takes 19.7 s to 43.5 s against 175.4 s on one H100, and GPU cost per rollout is 0.0150against0.0294.
- Training took 88 minutes and about 28,against180minutesandabout54, with the same recipe and data.
- The Scout cascade lifts it to 0.531 final-list recall@12 (+0.117 paired). It was measured on qwen only.
The full comparison, the dense against mixture-of-experts table and the training and evaluation observations are in Why the final results use wayfinder-qwen instead of this model on the wayfinder-glimmer model card.
Introduction
wayfinder-qwen is Qwen3.6-35B-A3B (35B parameters, 3B active per token) post-trained with LoRA supervised fine-tuning, merged into the base weights, to work as a code-search subagent. A coding agent hands it a brief such as "where does the router decide that a request matches a route with path variables?". The model plans, searches an unfamiliar repository with grep, glob and read_file, optionally calls semantic_search over a voyage-code-4 vector index, and returns a ranked list of path:start-end ranges with a one-line reason each, a summary and the gaps it could not establish. The parent agent reads that report instead of searching itself.
The weights are bf16 safetensors (26 shards) with the config, tokenizer and chat template of Qwen3.6-35B-A3B unchanged. This repository is a weights release: it holds no training data, trajectories or task text. The training data is a separate gated dataset (access by request, manual approval): hweller1/wayfinder-training-data. It holds 1,372 of the 1,383 examples (11 were removed before release: 8 from an AGPL-3.0 repository and 3 generated through a third-party host).
Latest results
The full pipeline has three steps. First, the model searches the repository with its own tools and reports a ranked list of files. Second, one hybrid search (voyage-code-4 vectors plus BM25 on hashed identifiers, top 100 chunks rolled up to files) is merged with the model's list by reciprocal rank fusion. Third, Voyage rerank-3 reorders positions 6 to 40 with the instruction "Rank source files a developer must edit or test for this change", and the first 5 are kept as they are.
Recall@12 on 200 held-out tasks (47 repositories never seen in training, 2 seeds per task, task as the unit):
Table with columns: Step, Recall@12| Step | Recall@12 |
|---|
| 1. The model's own list | 0.414 |
| 2. After the hybrid merge | 0.493 |
| 3. After the rerank | 0.531 |
The whole cascade adds +0.117 [+0.095, +0.140], paired by task. Recall@5 moves from 0.336 to 0.345, which is not significant, so these data show no gain at the top of the list. The list gets longer, and precision@12 falls from 0.416 to 0.303. The cascade adds about 0.4 s per search.
These are properties of the Scout pipeline around the weights, which needs the voyage-code-4 index and the rerank call. The weights alone give the 0.414 line.
Against baselines. The same 200 held-out tasks, grep arm, same explore loop, prompt and 40-turn cap, two seeds, reported recall (the share of gold files in the report call). Agents-A1-35B is an open-weight agentic model of the same size, run unmodified.
Table with columns: Searcher, Reported recall, Recall@5, Turns per task, Cost per search| Searcher | Reported recall | Recall@5 | Turns per task | Cost per search |
|---|
| wayfinder-qwen, own list | 0.415 [0.377, 0.452] | 0.335 | 9.5 | 0.045(open−priceequivalent);0.015 measured GPU cost |
| Agents-A1-35B | 0.313 [0.280, 0.348] | 0.247 | 34.1 | $0.113 (open-price equivalent) |
wayfinder-qwen beats the same-size baseline by +0.102 [+0.078, +0.127] paired by task, in a third of the turns and at about a third of the cost per search (the open-price equivalent for both). In the coding-agent study below, handing a coder the files of wayfinder-qwen lifts the pass rate far above no search (0.07).
Coding pass rate (34 tasks from 8 repositories, 2 seeds, a coder with no search tools that can open only the files it is handed): 0.824 [0.71, 0.93] with wayfinder-qwen and the cascade, against 0.074 with no search and 0.971 when handed the right files. Three other searchers (Sonnet 5.5 high, GPT-6.1 Sol and Agents-A1-35B) scored 0.85 to 0.87 in an earlier run without the cascade. The differences between searchers are unresolved on 34 tasks, and 16 of the tasks come from one repository.
Inside Muse Code (26 tasks from 18 repositories, one run per task, main agent muse-spark-1.3-contributor), adding Wayfinder cut cost per task from 0.342to0.195 and the tokens the main agent reads from 887K to 441K. The right files found and precision@12 are the same within noise (recall@12 0.590 to 0.536, difference -0.053 [-0.127, +0.015]). Recall@5 is lower, and the median search is about 25 s slower. The claim is cost and tokens, not better accuracy.
Serving
Tested with vLLM 0.32.0, one H100, online FP8 quantization of the bf16 checkpoint (--quantization fp8, not Qwen's own FP8 release) and, for the speed numbers below, multi-token prediction with 2 draft tokens. Every number in this card was measured with FP8. bf16 serving was not evaluated. The tool-call and reasoning parsers are required; without --tool-call-parser qwen3_coder the tool calls come back as plain text. The checkpoint's own chat template is used (no --chat-template).
pip install "vllm==0.32.0"vllm serve hweller1/wayfinder-qwen-35b-a3b \ --served-model-name wayfinder-qwen \ --quantization fp8 --max-model-len 65536 --gpu-memory-utilization 0.92 \ --enable-prefix-caching --language-model-only --max-num-seqs 32 \ --enable-auto-tool-choice \ --tool-call-parser qwen3_coder --reasoning-parser qwen3 \ --override-generation-config '{"temperature": 0.85, "top_p": 0.95, "top_k": 20}' \ --speculative-config '{"method": "qwen3_next_mtp", "num_speculative_tokens": 2}' \ --port 8000
Drop the --speculative-config line to serve without multi-token prediction. The prediction head is the one Qwen shipped. It was not fine-tuned. Its acceptance rate was 70.2% of draft tokens (60,421 of 86,045) in the 12-rollout latency run and 70.5% and 72.5% in two end-to-end launches. The held-out retrieval numbers below were produced with it off. Quality with it on was checked on 12 rollouts, on the end-to-end coding study and on the Muse Code run, not on the held-out set.
The model reasons before each tool call and was trained and evaluated with its own earlier reasoning sent back on every request. The chat template renders earlier reasoning, but vLLM 0.32.0 reads only the reasoning key of an assistant message and silently drops reasoning_content, which gives empty think blocks in the rendered prompt. vLLM also returns reasoning under the reasoning key, so copy it back unchanged into reasoning when you append the assistant turn. A client that drops earlier reasoning, or sends it under reasoning_content only, is outside what the model was trained on. The chat template needs tool-call arguments as a dict. Sampling used in the evaluations: temperature 0.85, top_p 0.95, top_k 20, thinking on (the template default).
Example request (one tool shown; the full harness offers grep, glob, read_file, semantic_search and a terminal report tool):
import json, urllib.requesttools = [{"type": "function", "function": { "name": "grep", "description": "Search the repository with ripgrep; files are ranked by match density.", "parameters": {"type": "object", "properties": {"pattern": {"type": "string"}, "context": {"type": "integer", "maximum": 5}}, "required": ["pattern"]}}}]body = {"model": "wayfinder-qwen", "tools": tools, "tool_choice": "auto", "max_tokens": 1024, "temperature": 0.85, "top_p": 0.95, "messages": [ {"role": "system", "content": "You are a code-search subagent. Find the files that answer the brief, then report ranked path:start-end ranges with reasons. Report as soon as the evidence covers the brief; do not exhaust the turn budget."}, {"role": "user", "content": "Where is the HTTP retry backoff maximum delay configured?"}]}req = urllib.request.Request("http://127.0.0.1:8000/v1/chat/completions", json.dumps(body).encode(), {"Content-Type": "application/json"})msg = json.load(urllib.request.urlopen(req))["choices"][0]["message"]print([c["function"]["name"] for c in msg.get("tool_calls", [])]) # expect ['grep', ...]
The tool schemas and system prompt used in training and evaluation come from the reference harness in the GitHub repository (serve/scout_tool_specs.json, serve/scout_product_prompt.md, also in this repository). Keep the convergence line "Report as soon as the evidence covers the brief; do not exhaust the turn budget." in the system prompt, because the training examples carry it.
Intended use
Use it as the explore or search subagent under a stronger parent model, inside a harness that executes its tool calls and offers the five tools (grep, glob, read_file, semantic_search, report). Its output is a list of leads for the parent to verify. It suits cases where latency and GPU cost per search matter.
Inside Muse Code

The intended deployment is the Scout plugin for Muse Code (scout-wayfinder, Muse Code 1.4.13 or later, verified on 1.4.14), with wayfinder-qwen served behind the Scout gateway.
What runs where. On the laptop: Muse Code, the plugin, local grep and file reads, and a Merkle sync that sends only changed files. The code is chunked on the laptop and the chunks go through the gateway to Voyage to be embedded (voyage-code-4). The vector store keeps vectors, keyed hashes, encrypted paths and line ranges, and no code. Hosted: the gateway (one Scout key per tenant, tenant isolation) and wayfinder-qwen on vLLM. Muse Code sends any code its agent reads to Meta, so use public repositories or code you may share.
How a search goes.
- The main agent (
muse-spark-1.3-contributor in our tests) decides to explore. A skill tells it to delegate broad "where" and "how" questions in unfamiliar repositories, and not exact-string lookups, files already open or trivial edits.
- A
PreToolUse hook helps: when the index is ready, a generic read-only subagent_spawn is rewritten to the plugin's read-only subagent scout-wayfinder/scout-explorer, and the first main-thread search of a session is denied once with a reason that names that subagent.
scout-explorer runs on muse-spark-1.3 at low effort, with write, edit, shell, web and memory tools disabled. It calls the Scout explore tool with a brief, which runs wayfinder-qwen over the repository and its index. Then it reads about the top five returned ranges to check them, runs one or two searches for named identifiers, and uses at most about eight tool calls in all.
- It hands the main agent up to 12 ranked
path:start-end why lines, checked files first and Scout's other files after them. The main agent treats these as leads and verifies them before editing.
What the weights see. The brief the main agent writes, the five tools and the explore prompt, in the form described under Training. The model never sees the main agent's own context. The model was trained on plain commit-subject questions, and recall on briefs written by a Muse Code parent was lower in our tests; see the evaluation below.
Setup, three commands (from the plugin's install guide):
uv tool install /path/to/scout && scout login --key <scout key>scout init --muse-code # adds the marketplace, installs and approves the plugincd /path/to/public/checkout && scout sync --wait && muse
Serve the model with deploy/modal/serve_qwen.py and point the gateway at it. The two-pane demo setup is in demo_panes.sh.
What to expect. In our 26-task Muse Code study, with Wayfinder the main agent cost 0.195pertaskagainst0.342 and read about half the tokens, with recall within noise but a slower search. The case for using it in Muse Code is cost and tokens, not better accuracy. Figures are under Latest results and under Evaluation.
Out of scope:
- Use outside that tool surface (other tool names, no
report tool, other prompts). It is untested there.
- General chat, general code generation, or any task where retention of general skills matters. Retention was not measured.
- Image or video input. The vision encoder of the base is present in the weights but was never trained or tested here (
--language-model-only).
- Use as the only safeguard on code changes.
- Searching repositories you are not permitted to read.
- Any use prohibited by the Muse Spark Open Usage Policy.
How it was trained
Tasks are mined from real commits in public repositories. The commit subject line is the question and the files the commit changed are the answers (the gold files). Muse Spark Open, the teacher, searched each task with grep, glob, read_file and report (1,062 of the 1,383 examples also offered semantic_search over a voyage-code-4 index). Only runs that found every gold file, opened every file they reported and called report in time were kept, and the 1,350 teacher examples that survived also stayed under the task's 75th-percentile turn count and 49,152 tokens (5,683 teacher rows in, 1,350 out). With 33 examples from Agents-A1-35B the set is 1,383 examples from 344 tasks in 153 of the 244 training-split repositories, 242 of those 244 under permissive licenses.
Qwen3.6-35B-A3B was then fine-tuned on those examples with LoRA supervised fine-tuning: rank 64, alpha 128, on the attention projections, the linear-attention projections and the shared expert of every MoE block (250 modules, 76.7M trainable parameters; the routed experts and the router are frozen), assistant-only loss, 2 epochs at learning rate 5e-5, 460 steps of 6 documents, 4x H200 data parallel, 88 minutes of wall time, then merged into the base weights. This is one training run with one seed. The recipe was not ablated: no run varied the data, rank or schedule against the released one, apart from the dev-set-only variant described under Training.
At inference time the Scout pipeline can refine the model's list. After the model reports, one hybrid search (voyage-code-4 vectors plus BM25) is merged with its list, and a Voyage rerank-3 pass reorders positions 6 to 40. On the 200 held-out tasks (47 repositories, two seeds) recall@12 goes from 0.414 for the model's own list to 0.493 after the hybrid merge and 0.531 after the rerank (+0.117 [+0.095, +0.140], paired by task). This is a property of the Scout pipeline and not of the weights alone: the same weights without the cascade score the first number. It also lengthens the list, so precision@12 falls from 0.416 to 0.303. It was measured in its own run of the held-out tasks, so it is not directly comparable to the reported-recall table under Evaluation.
How the training data was mined
Task pool and split. The tasks come from a pool of 1,660 public tasks in 316 repositories, each one a real commit. Splits are made by repository, never by task: 80% train, 10% dev, 10% test by repository count, assigned deterministically (seed 20261026) and stratified so each split's language and category mix tracks the whole pool. Ten further repositories, which come from Scout's 50-task eval, were held out entirely. That leaves 244 train, 31 dev and 31 test repositories, and no repository appears in two splits. A task entered the training set only if its gold files exist at the base commit, a single grep of the commit subject does not already find all of them, a closed-book probe does not name a gold path (it flagged 1 of 421 probed tasks), and at least one gold file is neither a test nor generated. 957 of the 1,660 tasks were accepted, 709 of them in the train split. The docs do not record the original miner's commit filters for these 1,660 tasks. The miner reused for later pools applies commit-scope, template-slot, whole-path and basename guards, strips conventional-commit prefixes and PR references, and keeps one task per source commit.
Leakage guards. The 17 tasks of an early end-to-end study were excluded from training (56 teacher rows dropped), although 7 of that study's repositories were seen in training. No dev, test, held-out or OOD repository enters the training data; the repository-overlap matrix shows zero shared repositories between SFT train and each of those sets.
Table with columns: Set, Tasks, Repositories, Shares a repository with training| Set | Tasks | Repositories | Shares a repository with training |
|---|
| Training (union over data versions; the released model used 344 tasks, 153 repositories) | 357 | 155 | n/a |
| Dev | 153 | 31 | 0 |
| Test | 152 | 31 | 0 |
| Held-out hard v1 | 200 | 47 | 0 |
How the held-out set was made harder. The 200 held-out tasks come from a separate mining pass (hard_v3): bug-fix and feature commits since 2025 whose gold files span at least two top-level directories and include at least one file that a grep over the question's own tokens cannot reach. The held-out repositories were chosen before any model's screening score was looked at. All 12 MongoDB-ecosystem repositories were held out, the rest were drawn round-robin by repository type, with at most 6 tasks per repository. Gold sets have 3 to 15 files (median 6).
Sampling and selection. The teacher ran over the 709 accepted train tasks in two passes, seeds 0 to 3 (spark_v1) and seeds 4 to 7 (spark_v2), plus some rows served through a third-party host of the same open weights. Settings were temperature 0.85, top_p 0.95, reasoning effort high, 40 turns, a 900 s clock, and a nudge line in the system prompt. A third pass (spark_v3) was not used for this model. The keep rule is applied in stages, and most rows are lost to the first two checks:
Table with columns: Stage, Rows left| Stage | Rows left |
|---|
| Rows in | 5,683 |
| Not an end-to-end eval task | 5,627 |
| Clean protocol (one report, budget not exhausted, no turn without a tool call) | 4,824 |
| Found every gold file | 2,372 |
| Every reported file was opened | 2,210 |
| At most the task's 75th-percentile turns | 1,844 |
| Fits 49,152 tokens | 1,353 |
| De-duplicated on task and seed | 1,350 |
Selecting on "found every gold file" uses the gold label after the fact, so the data holds only successful runs and favors tasks the teacher could solve. There was no hindsight relabelling in the released data. A later experiment that rewrote final reports to list every gold file the run had seen showed no detectable difference on the held-out set (recall@12 0.5325 against 0.5312).
Trajectories. Each example is one task. The request is the plain commit subject, and the teacher worked from the repository at the base commit with grep, glob, read_file and report. semantic_search over a voyage-code-4 index was offered when an index existed: 1,062 examples had it and 321 were grep-only. An example holds the system prompt, the request, assistant turns with reasoning and tool calls, the tool results, and a final report call with ranked path:start-end ranges. The trained model never saw a parent-written brief. Teacher data in that form, with 80% parent-style briefs, made no detectable difference at equal size, and recall on the briefs a Muse Code parent wrote was 0.033 lower than on plain questions, a result the pre-registered rule calls unclear (interval [-0.012, +0.077]).
Does better search predict coding success? The evidence is mixed. In round 4 of the end-to-end study (off-the-shelf harnesses, 892 non-oracle runs), pass rate rose from 4% for runs that read none of the gold files to 39% for runs that read all of them. Within a task the slope is +11 points [+4, +18] over 139 tasks. That is an association, not a controlled experiment, and the round-4 tasks were picked without an oracle check, so the study's no-lift null was withdrawn. In the handed-files study, where a fixed coder opened only what the subagent returned, any search subagent lifted the pass rate far above no search on the 34 headroom tasks (about +0.8), the four subagents were not separable, and file recall was a weak predictor of passing. In the separate 83-task comparison of wayfinder-glimmer, untrained Glimmer and the teacher, the task-level correlation between recall and pass was 0.19 to 0.42 within a condition (0.25 [0.10, 0.39] pooled), and runs passed 84% to 96% when the report held every gold file against 74% to 75% when it did not. A +0.06 recall gain was therefore expected to move pass rate by well under 0.05. The tasks cluster in a few repositories, so the effective sample is smaller than the task counts. Recall is a proxy, and coding pass rate is a coarse readout of it here.
Where to find the details. The trajectories behind these counts, with task text, are in the gated dataset hweller1/wayfinder-training-data (access by request, manual approval). The split rule and seed are in build_splits.py.
Training
- Base model: Qwen3.6-35B-A3B (
Qwen/Qwen3.6-35B-A3B, Apache-2.0), a hybrid of Gated DeltaNet and gated-attention layers with 256 routed experts per MoE layer.
- Method: LoRA supervised fine-tuning, rank 64, alpha 128, on the attention projections of the 10 gated-attention layers, the
in_proj_qkv, in_proj_z and out_proj projections of the 30 Gated DeltaNet layers, and the shared expert of all 40 MoE blocks (250 modules, 76.7M trainable parameters). The 256 routed experts and the router are frozen. The adapter was merged into the base shards and saved as bf16, so serving needs no LoRA support.
- Data: 1,383 examples rendered with the official Qwen3.6 chat template (47.2M tokens, 6.9M of them assistant tokens, all carrying loss; every assistant turn keeps its reasoning). They come from 344 tasks in public repositories, all from the training split, none from the test, development or held-out sets. The tasks come from 153 of the 244 repositories in the training split. Of those 244, 242 are under permissive licenses (MIT 129, Apache-2.0 98, BSD-3-Clause 12, BSD-2-Clause 2, ISC 1), one is AGPL-3.0 and one is no longer on GitHub, so its license could not be checked (GitHub license API, 2026-11-02; list in
eval/results/train_repos_license.csv in the GitHub repository). The 344 tasks are not listed in this release, so these counts cover the whole training split, and either of those two repositories may be among the 153. 1,350 examples are Muse Spark Open teacher trajectories (1,347 from self-hosted replicas of the open weights, 3 from a third-party host of the same open weights; none from the Meta API) and 33 are Agents-A1-35B trajectories. Only runs that found every gold file, opened every file they reported and called report in time were kept.
- Schedule: 2 epochs (460 steps of 6 documents), learning rate 5e-5 with cosine decay to 10%, 5 warmup steps, one document per sequence (no packing, because the recurrent layers would leak state between packed documents), 4x H200, 88 minutes.
- Single training run (seed 0). Results describe this checkpoint, not the recipe. A second variant that upweighted examples where semantic search found a gold file grep had missed was trained and evaluated on the development set only. It was no better and is not released.
The trajectories and task text are not in this repository. They are in the gated dataset hweller1/wayfinder-training-data (access by request, manual approval; 1,372 of the 1,383 examples). Training tasks were drawn from public repositories only.
Task shapes it was trained on
What the examples look like: one user message holding a short request, then a loop of assistant turns (reasoning, then one or more tool calls) and tool results, ending in a report call. The request is the subject line of a real commit, for example "Sanitize username used in proxy job names by splitting on underscores" or "Remove deprecations from OllamApi and AnthropicApi". Subject lines are one line each, median 8 words (range 3 to 98). The right files are the files that commit touched, including test files.
One limit on these tables: the list of the 344 tasks actually used was not saved outside the training volume. The tables below are for the 357 training-split tasks used across all versions of this training data (155 repositories), which differ from the 344 by at most 13 tasks. All 357 are in the training split.
Table with columns: Task category (357 tasks), Tasks, Share| Task category (357 tasks) | Tasks | Share |
|---|
| implementing_new_features | 138 | 38.7% |
| refactoring | 74 | 20.7% |
| paying_tech_debt | 54 | 15.1% |
| modernize | 36 | 10.1% |
| cybersecurity_bug_finding | 29 | 8.1% |
| onboarding | 19 | 5.3% |
| db_schema_rot | 4 | 1.1% |
| qa_over_codebases | 3 | 0.8% |
| splitting_monolith | 0 | 0.0% |
Categories come from the benchmark the tasks were mined from and describe the commit, not a hand label. No category is named bug fixing; cybersecurity_bug_finding is the nearest, at 8% of the tasks.
Table with columns: Language (majority gold-file extension), Tasks, Share| Language (majority gold-file extension) | Tasks | Share |
|---|
| Python | 83 | 23.2% |
| TypeScript/JavaScript | 72 | 20.2% |
| Rust | 71 | 19.9% |
| C/C++ | 41 | 11.5% |
| Go | 38 | 10.6% |
| Ruby | 15 | 4.2% |
| Other | 14 | 3.9% |
| Swift | 9 | 2.5% |
| C# | 8 | 2.2% |
| Java/Kotlin | 6 | 1.7% |
Table with columns: Right files per task, Tasks, Share| Right files per task | Tasks | Share |
|---|
| 1 | 62 | 17.4% |
| 2 to 3 | 132 | 37.0% |
| 4 to 6 | 116 | 32.5% |
| 7 or more | 47 | 13.2% |
The median is 3 right files per task (range 1 to 12, mean 3.8). The 200-task held-out set used in Evaluation is harder in shape: 3 to 15 right files, median 6, at least one non-test right file that neither the words of the request nor a grep for its rarest terms reaches.
Repository type was not recorded for the training tasks (it exists only for the held-out set). Tasks per repository: 155 repositories, at most 13 tasks from one repository (starkillerOG/reolink_aio), then 10 each from github/gh-aw-mcpg and pixlcore/xyops. Repository licenses of those 155: MIT 85, Apache-2.0 59, BSD-3-Clause 9, BSD-2-Clause 1, AGPL-3.0 1.
Tool mix. What is known from the build summaries: of the 1,383 examples, 1,062 offered semantic_search alongside the other four tools and 754 of them called it at least once; the rest used grep, glob and read_file only. The per-tool call counts inside the training trajectories were not recomputed, because the trajectories are on the training volume and not in the repositories used for this card. For orientation only, and not the training mix: in the model's own held-out rollouts (400 rollouts, median 8 turns) read_file was 53.5% of tool calls, grep 32.5%, glob 6.2%, semantic_search 4.2% and report 3.6%.
Evaluation
All numbers use the same explore loop, system prompt, 40-turn cap and two seeds, with earlier reasoning retained and verified to reach the prompt. "Reported recall" is the share of gold files in the report call (at most 12 files), which is what a parent agent receives. Intervals are 95% bootstrap intervals over tasks. The semantic arm adds semantic_search over a voyage-code-4 index. Every number below is from the FP8 serving described above.
Held-out retrieval: 200 tasks, 47 repositories never seen in training
Two seeds per task, so 400 rollouts per arm and 800 in total, with no errors. Run once, with MTP off, and not used to choose between models.
Table with columns: Model, Reported recall, grep, Reported recall, with semantic search, Recall@5, grep, Turns per task (grep), Ended by report (grep)| Model | Reported recall, grep | Reported recall, with semantic search | Recall@5, grep | Turns per task (grep) | Ended by report (grep) |
|---|
| wayfinder-qwen | 0.415 [0.377, 0.452] | 0.427 [0.388, 0.465] | 0.335 [0.301, 0.368] | 9.5 | 0.96 |
| Agents-A1-35B, same tasks | 0.313 [0.280, 0.348] | 0.352 [0.319, 0.387] | 0.247 [0.217, 0.279] | 34.1 | 0.47 |
Paired by task, wayfinder-qwen minus Agents-A1: +0.102 [+0.078, +0.127] on the grep arm and +0.075 [+0.051, +0.098] with semantic search. The all-gold rate (every gold file in the report) is 0.07 on the grep arm. The malformed tool-call rate was 0.05% of calls, and no tool markup leaked into message content.
On a 50-task development set with two seeds (the gate before the held-out run, so a selection set), reported recall was 0.375 [0.293, 0.458] on the grep arm and 0.385 [0.305, 0.468] with semantic search.
Speed and cost per search
12 development tasks, seed 0, grep arm, one stream, one H100 container, same harness. This is a small sample that sets the shape and not tight intervals.
Table with columns: Setup, Median wall time per search, Median model time per turn (p90), Median turns, Decode rate| Setup | Median wall time per search | Median model time per turn (p90) | Median turns | Decode rate |
|---|
| wayfinder-qwen, FP8, MTP on (2 draft tokens) | 19.7 s | 2.1 s (6.6 s) | 9.5 | 286 tok/s |
| wayfinder-qwen, FP8, MTP off | 43.5 s | 3.6 s (9.7 s) | 10.5 | 185 tok/s |
Reported recall on these 12 tasks was 0.20 with MTP on and 0.19 with it off. With n=12 no inference is drawn from that.
At a concurrency of 14 on the held-out set, GPU cost per rollout at the H100 list price of 3.95perhour(vLLMloadincluded)was0.0150 on the grep arm and $0.0144 with semantic search (400 rollouts per arm).
End to end: pass rate of a coding agent handed the searcher's files
34 tasks from 8 repositories, two seeds (68 runs per condition), selected because a coder cannot solve them without finding the code. A fixed coding model has no search tools and can only open the files the subagent returned; held-out tests are absent from its sandbox. MTP was on for wayfinder-qwen in this study.
Table with columns: What the coder is handed, Pass rate| What the coder is handed | Pass rate |
|---|
| No search | 0.07 (5 of 68) |
| wayfinder-qwen | 0.87 (59 of 68) |
| Gold files (ceiling) | 0.97 (66 of 68) |
wayfinder-qwen lifts the pass rate by +0.794 [+0.676, +0.897] over no search; the lift survives a repository-cluster bootstrap ([+0.595, +0.871]). The files handed over contained 0.73 of the gold files on average. Caveat: the set is concentrated, with 16 of the 34 tasks from one repository, so the effective sample is closer to 8 repositories, and the searchers sit near the ceiling. A separate, stricter task set reached only 4 usable tasks (8 runs): wayfinder-qwen passed 2 of 8 against 1 of 8 with no search, and nothing was resolved there. This run did not use the cascade; the cascade run (0.824 [0.71, 0.93], 34 tasks, 2 seeds) is under Latest results.
Inside Muse Code: 26 tasks, one seed
wayfinder-qwen as the chat model behind a Scout explore call in Muse Code, on 26 tasks from 18 repositories, one seed, MTP on. Calibration scale only.
Table with columns: Arm, Recall@5, Recall@12, Precision@12, Files reported, Median session| Arm | Recall@5 | Recall@12 | Precision@12 | Files reported | Median session |
|---|
| Stock Muse Code, no Scout | 0.413 | 0.600 | 0.381 | 15.0 | 65 s |
| Scout with wayfinder-qwen | 0.358 | 0.496 | 0.365 | 10.9 | 118 s |
wayfinder-qwen is below stock Muse Code on recall@12: -0.104 [-0.163, -0.051] (the repository-cluster interval also excludes zero). Part of that gap is report length (10.9 files against 15.0), and precision@12 is level. A Scout search with wayfinder-qwen is still about 1.8 times slower than stock Muse Code on these tasks.
Where it does well and where it does not
Two evaluations carry the strata below. Both are hard by construction (see Task shapes), so they say how the model does on tasks where the right files are not named by the request, not how it does on an average task. Intervals are 95% paired bootstrap intervals over tasks and are not adjusted for the number of strata, so read the small ones as direction only. A stratum with fewer than 8 tasks is shown as "not enough tasks".
200 held-out tasks: the model's own list, and after the cascade
Recall@12 of three lists on the same rollouts (two seeds per task, seeds averaged, task as the unit): the model's own list, the list after hybrid search merged in, and the list after rerank (the final list). "Change" is final minus the model's own list.
Table with columns: Stratum, Tasks, Model's own list, After hybrid, After rerank, Change| Stratum | Tasks | Model's own list | After hybrid | After rerank | Change |
|---|
| All | 200 | 0.414 | 0.493 | 0.531 | +0.117 [+0.095, +0.140] |
| Category | | | | | |
| implementing_new_features | 119 | 0.392 | 0.459 | 0.503 | +0.112 [+0.083, +0.142] |
| paying_tech_debt | 36 | 0.466 | 0.558 | 0.593 | +0.127 [+0.079, +0.177] |
| refactoring | 25 | 0.477 | 0.570 | 0.627 | +0.151 [+0.092, +0.217] |
| modernize | 17 | 0.388 | 0.478 | 0.467 | +0.080 [+0.027, +0.136] |
| cybersecurity_bug_finding, db_schema_rot | 2, 1 | not enough tasks | | | |
| Language | | | | | |
| TypeScript/JavaScript | 50 | 0.414 | 0.508 | 0.548 | +0.134 [+0.088, +0.185] |
| Java/Kotlin | 28 | 0.389 | 0.454 | 0.494 | +0.105 [+0.045, +0.173] |
| Go | 18 | 0.428 | 0.417 | 0.508 | +0.080 [+0.000, +0.173] |
| Other | 18 | 0.340 | 0.415 | 0.430 | +0.090 [+0.032, +0.159] |
| C# | 18 | 0.509 | 0.605 | 0.652 | +0.143 [+0.102, +0.183] |
| Swift | 16 | 0.453 | 0.495 | 0.525 | +0.073 [+0.018, +0.136] |
| Rust | 16 | 0.390 | 0.556 | 0.554 | +0.164 [+0.109, +0.223] |
| C/C++ | 15 | 0.469 | 0.513 | 0.583 | +0.113 [+0.027, +0.209] |
| Python | 13 | 0.326 | 0.462 | 0.476 | +0.151 [+0.086, +0.221] |
| Ruby | 8 | 0.434 | 0.516 | 0.521 | +0.087 [+0.000, +0.191] |
| Right files per task | | | | | |
| 3 to 5 | 77 | 0.485 | 0.552 | 0.567 | +0.082 [+0.052, +0.116] |
| 6 to 8 | 62 | 0.405 | 0.497 | 0.545 | +0.141 [+0.096, +0.190] |
| 9 or more | 61 | 0.334 | 0.415 | 0.472 | +0.138 [+0.105, +0.172] |
(No held-out task has fewer than 3 right files, so there is no 1 to 2 row.)
Where it does better: the model's own list is strongest on C# (0.509, 18 tasks), on tasks with 3 to 5 right files (0.485, 77 tasks) and on refactoring and paying_tech_debt (0.477 and 0.466). The cascade adds recall in every stratum with at least 8 tasks, and the interval excludes zero in all of them except Go and Ruby, where the lower end is 0.000. Where it ties: in Go and Ruby the gain is not separable from zero (18 and 8 tasks), and for Rust and modernize the hybrid merge did the work and the rerank added nothing (Rust 0.556 to 0.554, modernize 0.478 to 0.467). Where it does worse: nowhere in this table is the final list below the model's own list, but the model's own list is weakest on Python (0.326, 13 tasks), Other languages (0.340, 18 tasks) and on tasks with 9 or more right files (0.334, 61 tasks). Recall of its own list falls as the number of right files rises (0.485, 0.405, 0.334), partly because a 12-file report caps recall on large tasks. The cascade also lengthens the list and lowers precision@12 from 0.416 to 0.303 (-0.113 [-0.142, -0.085]). Repository-type strata exist for this set (26 types); only 10 have 8 or more tasks and none is reported here.
26 tasks in Muse Code: Muse Code alone against Muse Code with Wayfinder
A second Muse Code run on 26 of the same held-out tasks (18 repositories, one run per task, default configuration with direct hand-off and the cascade, wayfinder-qwen behind Scout). Same parent model on both sides, so a pair differs only by the Wayfinder explore call. Files found is the number of right files in the final list of 12 or fewer. The table under Evaluation is an earlier run of the same 26 tasks under a different protocol; both show Muse Code with Scout below stock Muse Code on recall@12.
Table with columns: Muse Code alone, With Wayfinder, Difference | Muse Code alone | With Wayfinder | Difference |
|---|
| Right files found (of 171 across 26 tasks) | 94 | 90 | -4 |
| Recall@12 | 0.590 | 0.536 | -0.053 [-0.127, +0.015] |
| Parent input tokens per task | 887K | 441K | fewer on 23 of 26 tasks |
| Muse cost per task (list price, excludes GPU) | $0.342 | $0.195 | -0.147[−0.205, -$0.096] |
| Median wall time | 80 s | 105 s | slower on 22 of 26 tasks |
Per task: more right files with Wayfinder on 6 tasks, the same on 11, fewer on 9.
Table with columns: Stratum, Tasks, More / same / fewer, Files found, alone to with| Stratum | Tasks | More / same / fewer | Files found, alone to with |
|---|
| implementing_new_features | 10 | 2 / 3 / 5 | 30 to 24 |
| paying_tech_debt | 8 | 2 / 4 / 2 | 30 to 31 |
| refactoring | 5 | not enough tasks | |
| modernize, db_schema_rot | 2, 1 | not enough tasks | |
| TypeScript/JavaScript | 9 | 2 / 6 / 1 | 34 to 36 |
| C#, Java/Kotlin, Other | 3 each | not enough tasks | |
| Go, Swift | 2 each | not enough tasks | |
| 3 to 5 right files | 11 | 1 / 5 / 5 | 31 to 25 |
| 6 to 8 right files | 9 | 3 / 3 / 3 | 32 to 31 |
| 9 or more right files | 6 | not enough tasks | |
Reading: with Wayfinder the coding agent reads about half as many tokens and spends about 43% less on Muse, and finds about as many right files overall, with wide uncertainty on a 26-task, one-run sample. It is slower. Where it loses ground in these data is implementing_new_features (5 of 10 tasks with fewer files) and tasks with 3 to 5 right files (5 of 11 with fewer); it ties in paying_tech_debt, TypeScript/JavaScript and tasks with 6 to 8 right files. No stratum with 8 or more tasks shows a gain of more than two files, and these samples are too small to put intervals on the per-stratum differences.
Single runs are noisy. In the three-task demo batch (5 runs each, same excalidraw task), Muse Code alone found 10, 10, 10, 5 and 8 of 11 right files and Muse Code with Wayfinder found 3, 8, 4, 3 and 8, a median of 10 against 4. In the 26-task run the same excalidraw task went the other way, 6 to 8. The rust-analyzer "Remove allows that are no longer necessary" task (12 right files) was a tie at 1 file in the 26-task run, and has no scored demo take in the files used here.
Hypothesis about the losses, offline and exploratory, not a tested claim: the tasks where Wayfinder loses are those whose right files are not named after the request (excalidraw "Remove image preview on image insertion", rust-analyzer "Remove allows...": the right files are spread over the codebase and their paths and contents do not contain the words of the request), so grep has no lexical way in, and the Muse parent's broader search may cover more ground. A check we could run offline on the 26 pairs, using the held-out set's own labels for how many non-test right files the request words do not reach: the tasks where Wayfinder found fewer files had a median of 0.67 of their non-test right files unreachable (9 tasks), against 0.40 for ties (11) and 0.37 for tasks where it found more (6). Rank correlation between that share and the change in recall@12 is -0.46 (permutation p = 0.018, n = 26). That points the same way as the hypothesis. It is one run, and it is one of five measures looked at. Two others were nominally significant too: number of directories (rho +0.49, p = 0.012), which runs the opposite way to a scatter explanation, with more directories going with better results for Wayfinder, and number of right files (rho +0.39, p = 0.048). With five looks the -0.46 does not survive a Bonferroni correction (0.018 x 5 = 0.09), the share is entangled with the number of right files, and no pre-registered test was run. Treat it as a lead, and note that the scatter half of the hypothesis is not supported.
Limitations
- In Muse Code, recall@12 is 0.496 against 0.600 for stock Muse Code without Scout (26 tasks, one seed), and the Scout path is slower end to end (118 s against 65 s median). The end-to-end and Muse Code samples are small and noisy.
- Whether thinking was on in every
explore call of the Muse Code run was not verified from a trace, so treat that part of the Muse Code result as unconfirmed.
- The held-out numbers were produced with MTP off, and the speed, end-to-end and Muse Code results with MTP on. Quality with MTP on has not been measured on the held-out set. All evaluations used FP8 online quantization.
- English-only task wording, public repositories only. Performance on private or unusual codebases is unknown, and Swift, C# and Java/Kotlin are thin in the training data.
License and notices
Three sets of terms apply. Keep all license files in this repository with any copy of the weights.
- Qwen3.6-35B-A3B. The base model is released by Alibaba Cloud under the Apache License 2.0 (
LICENSE).
- Muse Spark Open derivative terms. Because the model was fine-tuned on outputs of Muse Spark Open, it is a "Derivative" under the Muse Model License, version "Muse Spark Open" (
LICENSE-MUSE-SPARK-OPEN.md, which includes the Usage Policy as Exhibit A; also provided as USE_POLICY-MUSE-SPARK-OPEN.md). The license permits publishing and distributing Derivatives. Its conditions: the license and Usage Policy travel with the weights; "Built with Muse Spark Open" must be displayed in the user interface or accompanying documentation of any product or service that uses this model; and any party offering this model as a Model as a Service with aggregate gross revenue above US$20 million in a twelve-month period needs a separate written agreement with Meta. Your use must comply with the Usage Policy.
- Agents-A1. 33 of the 1,383 training examples are trajectories from Agents-A1-35B (InternScience), released under the Apache License 2.0. The training recipe adapts the Agents-A1 work (arXiv 2606.30616).
Meta claims no ownership of outputs generated by the model. The software and outputs are provided as is, without warranty. See NOTICE.
Future work
After release we trained 13 further variants (data mixes, hindsight relabelling, student rejection sampling with cascade-aware selection, an experts LoRA) and compared each with this model on 453 paired tasks. None changed final-list recall@12 by a detectable amount. What we learned:
- Sampling and selection beat further SFT. Pooling two independent rollouts with a frozen selector raised final recall@12 by +0.024 (95% CI +0.015 to +0.033) at about twice the explorer tokens. Gains saturate by three to four rollouts. A better selector is the most promising lever.
- More data of the same kind has plateaued. Future training needs a different signal, not more volume. Cascade-aware training did make rollouts about 14% cheaper at equal recall.
- On-policy distillation is untested on this model. The tokenizer mismatch with the teacher blocked it. A same-tokenizer teacher or cross-tokenizer distillation is open.
Citation and links
@misc{wayfinder_qwen_2026, title = {wayfinder-qwen: a fast code-search subagent post-trained from Qwen3.6-35B-A3B}, author = {Weller, Henry}, year = {2026}, note = {Voyage AI. Built with Muse Spark Open.}, url = {https://huggingface.co/hweller1/wayfinder-qwen-35b-a3b}}
The first model trained with the same recipe, wayfinder-glimmer (Muse Glimmer 30B base), is a separate repository and is not part of the final results.