Qwen Shared Parser Compiler
The one idea you need
A language model silently reads a chain of wrap-around arithmetic steps. A small attached reader taps its internal activity, transcribes each step into a machine recipe — start value, operation, number — and a calculator runs the recipe. The model itself never writes the answer.
The question
When a language model quietly works through a multi-step math problem in its head, can a small add-on read its internal activity and rebuild the exact steps it took?
What we found
Only when every step is taught directly. Given step-by-step labels, the add-on rebuilds short programs well — nearly 4 in 5 four-step problems run exactly right — but accuracy fades to 39% at twelve steps and under 1% at twenty-four. Reword the same problems and it collapses toward guessing. Training on final answers alone never finds this ability at all.
Why it matters
To pull runnable, auditable structure out of a frozen model, supervise every intermediate step — rewarding only the final answer neither discovers nor preserves it. And expect brittleness: what works on the trained wording and length will not carry over.
On this page
Results at a glance 6
How to read
Horizontal axis is how many steps the problem has; vertical axis is how often the run gives the exactly correct answer, higher is better. One line teaches the reader each step; two lines read only the final answer.
Takeaway → The step-taught line starts high and slides down as programs lengthen, while both answer-reading lines stay flat at the bottom near random guessing throughout.
Data table
| program length (steps) | trace-supervised parser | direct answer head | answer-only parser |
|---|---|---|---|
| 4 | 78.5% | 2% | 2.3% |
| 8 | 62.5% | 0% | 2.3% |
| 12 | 39.1% | 1.2% | 2% |
| 24 | 0.4% | 1.6% | 3.1% |
Numbers from experiments/qwen_shared_parser_compiler/analysis/final_metrics.csv (run main_qwen35_after_op_trace_controls)
Technical framing
Exact answer accuracy vs program length (standard wording) — Only trace supervision installs an executable latent compiler; it works through length 12 but collapses at length 24.
How to read
Both lines are the same step-taught reader on identical math programs; one uses the exact training wording, the other reworded prompts. Vertical axis is how often the answer is exactly right, higher is better; horizontal is program length.
Takeaway → The reworded line lies flat near guessing at every length while the trained-wording line rides far above it — the reader keyed on phrasing, not meaning.
Data table
| program length (steps) | standard wording | paraphrased wording |
|---|---|---|
| 4 | 78.5% | 4.3% |
| 8 | 62.5% | 0.8% |
| 12 | 39.1% | 2.3% |
| 24 | 0.4% | 0.4% |
Technical framing
Trace parser: trained wording vs paraphrased wording — The learned parser is format-sensitive: rewording the same programs drops execution to near chance at every length.
How to read
Grouped bars at each program length compare the working step-taught reader before extra training, after training on final answers only, and after the same training at a gentler pace. Taller bars are better.
Takeaway → After answer-only training the bars for longer programs fall to the floor; even the gentle version keeps only the four-step case standing.
Data table
| program length (steps) | trace parser (before continuation) | then answer-only training | then answer-only, 0.1x LR |
|---|---|---|---|
| L=4 | 78.5% | 60.2% | 78.1% |
| L=8 | 62.5% | 0.4% | 6.6% |
| L=12 | 39.1% | 1.2% | 0.8% |
| L=24 | 0.4% | 0.8% | 0% |
Technical framing
Answer-only continuation erodes the installed parser (standard wording) — Final-answer-only training damages the trace-installed interface; low learning rate preserves length 4 but still loses longer programs.
How to read
Three lines track the step-taught reader by program length: how often each operation is read right, how often each number is read right, and how often the whole program is exactly right. Higher is better.
Takeaway → Per-step reading stays high, but the whole-program line falls far faster — one wrong step anywhere spoils the answer, so small errors compound.
Data table
| program length (steps) | operation symbol | argument value | whole program exact |
|---|---|---|---|
| 4 | 99.9% | 94% | 78.1% |
| 8 | 99.2% | 94.8% | 62.1% |
| 12 | 99% | 93.2% | 38.7% |
| 24 | 82.6% | 70.7% | 0% |
Technical framing
Why execution collapses: per-step parse accuracy vs length (trace parser) — Small per-step argument errors compound: every symbol must be right, so ~94% per-step accuracy already halves exact execution by length 12.
How to read
Each line is a different reader design, scored by how often the run gives the correct answer across program lengths, higher is better. Designs differ in how deep inside the model they read and how they locate each step's number.
Takeaway → Reading deeper internal activity and pinning each number beside its operation lift the lines highest, while the shallowest design dies past four steps.
Data table
| Program length (operations) | Layer-4 probe | Layer-12 probe | Layer-12 + 4-way arg reader | Layer-12 + after-op arg reader | Main run (after-op, more training) |
|---|---|---|---|---|---|
| 4 | 50.8% | 50% | 75.8% | 75% | 78.5% |
| 8 | 3.1% | 15.6% | 39.1% | 43% | 62.5% |
| 12 | 0% | 3.1% | 9.4% | 18% | 39.1% |
| 24 | 0% | 1.6% | 0.8% | 3.9% | 0.4% |
Numbers from experiments/qwen_shared_parser_compiler/analysis/final_metrics.csv
Technical framing
Architecture ablation: which parser designs execute longer programs — Deeper read layer and the after-operation argument reader each extend executable program length; layer-4 probes die past 4 ops.
How to read
Two lines by program length show how much probability the step-taught system versus a plain answer-reader places on the true answer. Higher is better; both settle onto a low floor marking random guessing.
Takeaway → The step-taught reader leads only at four steps, then drops to meet the answer-reader at random-guess level — past four steps its edge disappears.
Data table
| Program length (operations) | Compiler + executor | Direct answer baseline |
|---|---|---|
| 4 | 8.4% | 1% |
| 8 | 1.2% | 1% |
| 12 | 1% | 1% |
| 24 | 1% | 1.1% |
Numbers from experiments/qwen_shared_parser_compiler/analysis/final_metrics.csv
Technical framing
Probability mass on the correct answer collapses to chance past 4 ops — Beyond 4 operations the executor's mass on the true answer matches the direct baseline's ~1% chance level: failure is total, not partial.
In the author’s words from the Report · “Abstract”
This experiment tests whether a frozen Qwen3.5-4B model can support a small trainable latent compiler that reads the full hidden sequence, recovers an ordered modular arithmetic program, and executes that program without emitting intermediate text. The best trace-supervised parser reaches 78.5% exact execution at length 4, 62.5% at length 8, and 39.1% at length 12 on the standard template. It falls to 0.4% at length 24 and does not transfer to paraphrased templates. Direct answer classification and answer-only parser training stay near 97-way chance. Answer-only continuation from a trace-installed parser is destructive for longer lengths.
Overview
This experiment tests whether a shared token parser can read a frozen Qwen hidden sequence, recover ordered program symbols, and configure an executable latent modular program without token-span inputs at inference time.
Lightweight code, logs, run JSON/CSV, analysis, and reports live in this directory. Saved checkpoints live under:
large_artifacts/qwen_shared_parser_compiler/checkpoints/The compiler uses shared token-level role and symbol heads, a monotonic operation slot reader, and an after-operation argument reader, so parser weights are reused across operation steps without span inputs at inference time.
Report
Rendered from reports/qwen_shared_parser_compiler_paper.md
Abstract
This experiment tests whether a frozen Qwen3.5-4B model can support a small trainable latent compiler that reads the full hidden sequence, recovers an ordered modular arithmetic program, and executes that program without emitting intermediate text. The best trace-supervised parser reaches 78.5% exact execution at length 4, 62.5% at length 8, and 39.1% at length 12 on the standard template. It falls to 0.4% at length 24 and does not transfer to paraphrased templates. Direct answer classification and answer-only parser training stay near 97-way chance. Answer-only continuation from a trace-installed parser is destructive for longer lengths.
Question
The experiment asks whether frozen Qwen hidden states contain enough structure for a small posttraining head to compile text into an executable latent program without being given token spans at inference time.
The target behavior is not just answer classification. The parser must predict:
- The initial residue modulo 97.
- One operation symbol per step: add, subtract, or multiply.
- One argument residue per step.
- Ordered slots for operation and argument tokens.
An exact modular executor then applies the compiled program.
Task
Each prompt describes a hidden value x modulo 97. A prompt gives an initial value and a list of update steps. The answer is the final value after all updates.
Training prompts use the standard wording:
Initial x = n.Step: add k.Step: subtract k.Step: multiply by k.
Evaluation uses both this standard wording and paraphrased wording. The main training lengths are 1 through 12. Evaluation lengths are 4, 8, 12, and 24.
Model
Qwen3.5-4B is loaded frozen in 4-bit mode. The trainable components are small heads over cached hidden states.
The final parser uses:
- A shared token MLP over every hidden token.
- Token role heads for init, operation, and argument positions.
- Token symbol heads for initial values, operation classes, and argument values.
- A monotonic slot reader for operation slots.
- An after-operation argument reader that anchors each argument slot to the learned operation slot and scores nearby following tokens.
- An exact differentiable modular executor for answer loss.
The parser receives full hidden sequences and attention masks. It does not receive gold token spans at inference time.
Training
The main trace run uses:
- Model:
Qwen/Qwen3.5-4B - Modulus: 97
- Max steps: 24
- Trace train lengths: 1-12
- Trace train examples: 4096
- Eval examples per split: 256
- Parser width: 768
- Trace steps: 1600
- Argument trace loss weight: 4
- Argument selection loss weight: 4
- Argument reader: after-operation window, width 8
Controls:
direct: answer classifier from the frozen answer-marker hidden state.compiler_answer_only: parser and executor trained only from final answer.compiler_trace: parser trained with symbol and selection trace labels.compiler_trace_then_answer: trace bootstrap followed by answer-only training.compiler_trace_then_answer_low_lr: same, with 0.1x answer-stage learning rate.
Main Results
Standard-template exact answer accuracy:
| Variant | L=4 | L=8 | L=12 | L=24 |
|---|---|---|---|---|
| Direct answer head | 2.0% | 0.0% | 1.2% | 1.6% |
| Trace parser | 78.5% | 62.5% | 39.1% | 0.4% |
| Answer-only parser | 2.3% | 2.3% | 2.0% | 3.1% |
Paraphrase-template exact answer accuracy:
| Variant | L=4 | L=8 | L=12 | L=24 |
|---|---|---|---|---|
| Direct answer head | 1.2% | 0.8% | 2.0% | 1.2% |
| Trace parser | 4.3% | 0.8% | 2.3% | 0.4% |
| Answer-only parser | 1.2% | 1.6% | 1.2% | 1.6% |
The trace parser learns a real executable interface on the trained wording and length range. The direct and answer-only controls do not.
Parser Diagnostics
Trace parser diagnostics on standard-template splits:
| Split | Init | Init pos | Op | Op pos | Arg | Arg pos | Program exact |
|---|---|---|---|---|---|---|---|
| L=4 | 100.0% | 100.0% | 99.9% | 100.0% | 94.0% | 95.1% | 78.1% |
| L=8 | 100.0% | 100.0% | 99.2% | 100.0% | 94.8% | 94.8% | 62.1% |
| L=12 | 100.0% | 100.0% | 99.0% | 100.0% | 93.2% | 93.7% | 38.7% |
| L=24 | 100.0% | 100.0% | 82.6% | 72.9% | 70.7% | 68.8% | 0.0% |
The parser solves initial values and operation slots inside the trained length range. Argument errors are small per step but compound strongly. At length 24, operation and argument localization also degrade.
Paraphrase diagnostics show a different failure. Init token selection remains high, but operation and argument slot selection break under wording shift. This indicates that the parser is format-sensitive rather than template-invariant.
Retention
Answer-only continuation after trace bootstrap:
| Variant | Split | L=4 | L=8 | L=12 | L=24 |
|---|---|---|---|---|---|
| Trace then answer | standard | 60.2% | 0.4% | 1.2% | 0.8% |
| Trace then answer, low LR | standard | 78.1% | 6.6% | 0.8% | 0.0% |
| Trace then answer | paraphrase | 3.1% | 2.0% | 2.0% | 1.2% |
| Trace then answer, low LR | paraphrase | 2.0% | 0.8% | 0.4% | 1.2% |
Answer-only continuation does not reliably preserve the parser. The low learning-rate variant preserves length 4 but loses longer standard lengths by the end of continuation.
Interpretation
The strongest positive result is that a small trace-supervised parser can read frozen Qwen hidden states and drive exact latent execution without span inputs at inference time. This is a genuine latent compiler result for the standard template through length 12.
The strongest negative result is that the learned parser is not robust. It does not extrapolate to length 24, does not transfer to paraphrased wording, and is not discovered from answer-only training. Final-answer continuation also damages the installed interface.
The main bottleneck is not modular execution. It is reliable parsing. Exact execution falls quickly when per-step operation and argument accuracies are below the high 90s, because every compiled symbol must be correct.
Conclusion
Frozen Qwen3.5-4B hidden states support a trace-supervised latent program compiler, but this parser is still too brittle to count as a broad intelligence gain recipe. The result supports the narrower claim that structured trace supervision can install an executable latent interface. It does not support the stronger claim that final-answer posttraining alone discovers or preserves such an interface.
The next best test is to train the parser inside Qwen with a small QLoRA adapter, rather than only training external heads over frozen hidden states.
Experiment log 12
Show the running log (12 entries, 2026-06-21)
Objective
Test whether a reusable token parser over frozen Qwen hidden states can recover ordered program symbols and drive an executable latent modular program without receiving token-span features at inference time.
Primary Questions
- Can shared token-level role and symbol heads recover initial values, operations, and arguments from the full hidden sequence?
- Does a monotonic slot reader reuse the same parser across later operation steps instead of learning private per-step query slots?
- Can trace bootstrap install an interface that generalizes to longer chains?
- Does answer-only continuation preserve the installed parser interface?
- Does answer-only training from scratch discover the interface?
- How sensitive is the learned parser to wording shifts?
Metrics
executor_accuracy: accuracy after argmax compilation and exact execution.executor_target_mass: differentiable executor probability assigned to the target answer.init_accuracy: compiled initial value accuracy.op_accuracy: per-step operation accuracy.arg_accuracy: per-step argument accuracy.program_exact: fraction of examples with all compiled symbols correct.direct_accuracy: direct answer classifier accuracy from the frozen Qwen answer-marker feature.
Artifact Layout
- Code and lightweight outputs:
experiments/qwen_shared_parser_compiler/ - Checkpoints:
large_artifacts/qwen_shared_parser_compiler/checkpoints/ - Run outputs:
experiments/qwen_shared_parser_compiler/runs/<run>/ - Analysis outputs:
experiments/qwen_shared_parser_compiler/analysis/
2026-06-21 Setup
Created the standalone experiment directory:
experiments/qwen_shared_parser_compiler/src/experiments/qwen_shared_parser_compiler/reports/experiments/qwen_shared_parser_compiler/runs/experiments/qwen_shared_parser_compiler/analysis/figures/large_artifacts/qwen_shared_parser_compiler/checkpoints/
Implementation plan:
- Cache padded full-sequence hidden states and sequence masks.
- Replace private step queries with shared token role heads.
- Use a monotonic differentiable rank reader to convert role scores into ordered operation and argument slots.
- Keep direct, answer-only, trace, and trace-then-answer variants.
- Evaluate standard and paraphrase template splits across short and long program lengths.
2026-06-21 Harness Smoke
Implemented the shared-parser harness:
- Full hidden-sequence feature caching.
- Shared token role heads for init, operation, and argument tokens.
- Shared token symbol heads for residues and operation classes.
- Monotonic differentiable rank reader for ordered operation and argument slots.
- Trace-time selection loss over token roles and ordered slot positions.
- Staged direct, trace, answer-only, and trace-then-answer variants.
- External checkpoint writing.
- Analysis summary and figures.
Verification:
- Source compilation passed.
- Stale path and standalone wording scans passed.
- Tiny random Llama smoke completed.
- Analysis generation completed.
- Checkpoints were written under
large_artifacts/qwen_shared_parser_compiler/checkpoints/smoke_tiny/.
Smoke iteration:
- The first smoke exposed unstable initial rank-reader losses because random role logits made cumulative role mass too large.
- Patched the parser to initialize role-head bias to
-2.5and raised default rank temperature to1.0. smoke_tiny_sparse_initcompleted with sane loss scale.
Next action: run a Qwen trace pilot to test whether shared role parsing generalizes from short trained chains to longer held-out chains.
2026-06-21 Qwen Pilot: Monotonic Shared Parser
Ran pilot_qwen35_shared_parser_l4_trace with frozen Qwen3.5-4B features, standard-template length-4 trace training, and evaluation at lengths 4, 8, 12, and 24 under standard and paraphrase templates.
Final standard-template metrics:
| Split | Exec | Init | Op | Arg | Program exact |
|---|---|---|---|---|---|
| L=4 | 50.8% | 100.0% | 93.8% | 89.8% | 50.8% |
| L=8 | 3.1% | 100.0% | 77.1% | 58.1% | 0.0% |
| L=12 | 0.0% | 100.0% | 74.1% | 42.4% | 0.0% |
| L=24 | 0.0% | 100.0% | 69.8% | 21.5% | 0.0% |
Added explicit slot-position diagnostics and reran the matched pilot_qwen35_shared_parser_l4_trace_diag condition for 400 steps. The diagnostic result showed operation positions were essentially solved on standard prompts, while argument positions drifted with sequence length:
| Split | Op pos | Arg pos | Op symbol | Arg symbol |
|---|---|---|---|---|
| L=4 | 100.0% | 90.8% | 97.9% | 89.3% |
| L=8 | 100.0% | 62.5% | 87.7% | 65.7% |
| L=12 | 100.0% | 45.2% | 88.2% | 48.6% |
| L=24 | 99.4% | 21.2% | 83.1% | 25.6% |
Interpretation:
- The init parser solved standard-template initial values.
- The operation slot reader generalized well on standard prompts.
- The independent monotonic argument reader was the length bottleneck.
2026-06-21 Iterations: Argument Reader
Added role_count_loss_weight to calibrate role counts. The matched pilot_qwen35_shared_parser_l4_count_trace run did not improve argument position drift; L24 argument-position accuracy remained about 21%.
Ran pilot_qwen35_shared_parser_l12_trace with trace training lengths 1-12. This exposed later slots during training and improved argument localization, but exact execution remained low because per-step errors compounded:
| Split | Exec | Op pos | Arg pos | Op symbol | Arg symbol |
|---|---|---|---|---|---|
| L=4 | 50.0% | 100.0% | 93.6% | 98.2% | 85.9% |
| L=8 | 15.6% | 100.0% | 87.5% | 96.8% | 78.9% |
| L=12 | 3.1% | 100.0% | 78.4% | 96.0% | 70.8% |
| L=24 | 1.6% | 100.0% | 70.1% | 95.2% | 62.3% |
Increased argument trace and selection weights in pilot_qwen35_shared_parser_l12_arg4_trace. This improved standard-template execution to 75.8% at L=4, 39.1% at L=8, and 9.4% at L=12.
Added arg_reader_mode=after_op, which anchors each argument reader to the learned operation slot and scores candidate argument tokens within a short following window. The matched pilot_qwen35_shared_parser_l12_after_op_arg4_trace run improved standard L=12 exact execution to 18.0% and L=24 to 3.9%.
Ran a stronger trace pilot, pilot_qwen35_shared_parser_l12_after_op_strong_trace, with 4096 trace examples, width 768, and 2400 steps. The best intermediate checkpoint was at step 1600:
| Step | L=4 exec | L=8 exec | L=12 exec | L=24 exec |
|---|---|---|---|---|
| 800 | 77.7% | 59.4% | 31.6% | 1.2% |
| 1600 | 78.5% | 62.5% | 39.1% | 0.4% |
| 2400 | 80.1% | 50.4% | 28.5% | 1.2% |
Decision:
- Promote the after-op argument reader, argument-weighted trace loss, width 768, 4096 trace examples, and 1600 trace steps to the main run.
- Keep L=24 and paraphrase splits as stress tests.
- Run direct and answer-only controls from scratch.
- Run answer-only retention variants to test whether final-answer continuation preserves the trace-installed parser.
2026-06-21 Main Qwen Trace/Control Run
Ran main_qwen35_after_op_trace_controls with frozen Qwen3.5-4B features, training lengths 1-12, standard-template training, standard/paraphrase eval splits, and 256 examples per eval split.
Final metrics:
| Variant | Split | L=4 | L=8 | L=12 | L=24 |
|---|---|---|---|---|---|
direct | standard | 2.0% | 0.0% | 1.2% | 1.6% |
compiler_trace | standard | 78.5% | 62.5% | 39.1% | 0.4% |
compiler_answer_only | standard | 2.3% | 2.3% | 2.0% | 3.1% |
direct | paraphrase | 1.2% | 0.8% | 2.0% | 1.2% |
compiler_trace | paraphrase | 4.3% | 0.8% | 2.3% | 0.4% |
compiler_answer_only | paraphrase | 1.2% | 1.6% | 1.2% | 1.6% |
Trace parser diagnostics on standard splits:
| Split | Init | Init pos | Op | Op pos | Arg | Arg pos | Program exact |
|---|---|---|---|---|---|---|---|
| L=4 | 100.0% | 100.0% | 99.9% | 100.0% | 94.0% | 95.1% | 78.1% |
| L=8 | 100.0% | 100.0% | 99.2% | 100.0% | 94.8% | 94.8% | 62.1% |
| L=12 | 100.0% | 100.0% | 99.0% | 100.0% | 93.2% | 93.7% | 38.7% |
| L=24 | 100.0% | 100.0% | 82.6% | 72.9% | 70.7% | 68.8% | 0.0% |
Interpretation:
- Trace supervision installs a useful standard-template parser up to the trained length range.
- Exact execution is limited by compounding per-step symbol errors.
- The parser does not extrapolate to length 24.
- The parser does not transfer to paraphrased prompt wording under this setup.
- Direct answer classification and answer-only parser training stay at chance.
2026-06-21 Main Qwen Retention Run
Ran main_qwen35_after_op_retention with the same parser recipe, then continued training from the trace-installed state using final-answer loss only.
Final metrics:
| Variant | Split | L=4 | L=8 | L=12 | L=24 |
|---|---|---|---|---|---|
compiler_trace_then_answer | standard | 60.2% | 0.4% | 1.2% | 0.8% |
compiler_trace_then_answer_low_lr | standard | 78.1% | 6.6% | 0.8% | 0.0% |
compiler_trace_then_answer | paraphrase | 3.1% | 2.0% | 2.0% | 1.2% |
compiler_trace_then_answer_low_lr | paraphrase | 2.0% | 0.8% | 0.4% | 1.2% |
Retention interpretation:
- Normal-rate answer-only continuation rapidly destroys the length-general part of the installed parser.
- Low-rate continuation preserves the first post-switch step, but it also collapses longer standard lengths by the end of the answer stage.
- Final-answer continuation is not a reliable preservation or improvement method for this parser.
2026-06-21 Analysis Snapshot
Generated:
analysis/final_metrics.csvanalysis/summary.mdanalysis/figures/direct_accuracy.pnganalysis/figures/executor_accuracy.pnganalysis/figures/program_exact.pngcheckpoint_manifest.csv
Large checkpoint files are stored under large_artifacts/qwen_shared_parser_compiler/checkpoints/.
2026-06-21 Final Audit
Final artifacts created:
reports/qwen_shared_parser_compiler_paper.mdreports/qwen_shared_parser_compiler_paper.htmlcheckpoint_manifest.csv
Verification:
- Source compilation passed:
python -m py_compile src/qwen_shared_parser_compiler_experiment.py src/analyze_qwen_shared_parser_compiler.py - Analysis generation passed:
python src/analyze_qwen_shared_parser_compiler.py - Checkpoint manifest validation passed for 18 saved checkpoints.
- No
.pt,.pth, or.ckptfiles are stored inside the lightweight experiment directory. - Standalone wording scan passed on the report files.
- Compile caches were removed after verification.
Artifact sizes:
experiments/qwen_shared_parser_compiler/: 876Klarge_artifacts/qwen_shared_parser_compiler/: 99M
Conclusion:
The after-operation shared parser installs a useful standard-template latent program interface under trace supervision, reaching 78.5% exact execution at L=4, 62.5% at L=8, and 39.1% at L=12. It does not extrapolate to L=24, does not transfer to paraphrase templates, and is not learned from answer-only training. Answer-only continuation damages the installed parser on longer standard lengths.
Figures 3
Data files 13
Result tables and metrics copied from the experiment folder — preview inline or open the raw file.
analysis/final_metrics.csv20 kBruns/main_qwen35_after_op_retention/results.json66 kBruns/main_qwen35_after_op_trace_controls/results.json62 kBruns/pilot_qwen35_shared_parser_l12_after_op_arg4_trace/results.json24 kBruns/pilot_qwen35_shared_parser_l12_after_op_strong_trace/results.json17 kBruns/pilot_qwen35_shared_parser_l12_arg4_trace/results.json23 kBruns/pilot_qwen35_shared_parser_l12_trace/results.json23 kBruns/pilot_qwen35_shared_parser_l4_count_trace/results.json18 kBruns/pilot_qwen35_shared_parser_l4_trace/results.json18 kBruns/pilot_qwen35_shared_parser_l4_trace_diag/results.json18 kBruns/smoke_tiny/results.json57 kBruns/smoke_tiny_after_op/results.json9.3 kBruns/smoke_tiny_sparse_init/results.json7.8 kB
Reproduce
This entry is source code or analysis only — there is no separate run to reproduce.