🔬Modal Research Exchange

{
  "activation_gate": {
    "applicable": true,
    "checks": [
      {
        "measures": "rollouts per distinct prompt in logged treatment batches",
        "metric": "executed_group_size_treatment",
        "one_of": [
          "1"
        ]
      },
      {
        "measures": "rollouts per distinct prompt in logged baseline batches",
        "metric": "executed_group_size_baseline",
        "one_of": [
          "8"
        ]
      },
      {
        "max": 0.9,
        "measures": "mean training reward over the first 2 treatment steps",
        "metric": "pilot_mean_reward",
        "min": 0.1
      },
      {
        "measures": "10th percentile over rollouts of (sum w)^2/sum w^2 for the kernel weights",
        "metric": "kernel_effective_neighbors_p10",
        "min": 8.0
      },
      {
        "measures": "fraction of treatment rollouts with |advantage|>1e-6",
        "metric": "frac_nonzero_advantage_treatment",
        "min": 0.5
      },
      {
        "measures": "Pearson correlation of b_i with a held-out 8-sample per-prompt mean reward, over 64 pilot prompts",
        "metric": "baseline_reward_corr",
        "min": 0.1
      }
    ],
    "reason": "A GS1 baseline only differs from a constant baseline if the kernel draws on several neighbors with varied rewards, and the prompts give a non-degenerate reward. The executed group size must actually be 1 for the treatment and 8 for the baseline."
  },
  "arms": [
    {
      "advantage": "group_mean",
      "group_size": 8,
      "groups_per_batch": 8,
      "lr": 4e-05,
      "name": "grpo_gs8",
      "seed": 0
    },
    {
      "advantage": "kernel_cross_prompt_baseline",
      "group_size": 1,
      "groups_per_batch": 64,
      "lr": 4e-05,
      "name": "gs1_kernel",
      "seed": 0
    }
  ],
  "base_model": "Qwen/Qwen3.5-2B",
  "baseline": "GRPO via the same client loop with group_size=8, groups_per_batch=8 and group-mean advantages. It uses the same model, LoRA rank, LR, steps, rollouts per step, max_tokens, renderer, reward, seed and GSM8K eval.",
  "batch_size": 64,
  "budget": {
    "gpu_hours": 2.0,
    "max_wall_minutes": 120
  },
  "command": "Custom client loop (python rx_gs1.py --arm {grpo_gs8|gs1_kernel}); the only custom part is the compute_advantages function.\n\nSetup:\n  import os, tinker\n  sc = tinker.ServiceClient(base_url=os.environ['TINKER_BASE_URL'])\n  tc = sc.create_lora_training_client(base_model='Qwen/Qwen3.5-2B', rank=32, seed=0)\n  Use the tinker_cookbook math_rl gsm8k env builder for prompts, renderer and reward.\n\nEach of 40 steps:\n  1. sampler = tc.save_weights_and_get_sampling_client(...).\n  2. Draw prompts from a fixed seed-0 shuffled order: GRPO takes 8 prompts x 8 samples, GS1 takes 64 prompts x 1 sample. max_tokens=512, temperature=1.0.\n  3. Grade with the env reward.\n  4. Compute advantages: GRPO uses r minus group mean. GS1 uses r_i minus a Gaussian-kernel-weighted mean over a 256-rollout window excluding i, with phi = (log prompt length, sampler mean prompt-token logprob) and bandwidth 0.5.\n  5. Build Datums with sampling logprobs and advantages.\n  6. tc.forward_backward(datums, loss_fn='importance_sampling').\n  7. tc.optim_step(tinker.AdamParams(learning_rate=4e-5)).\n\nAfter training: run save_weights_for_sampler, then greedy-decode all 1319 GSM8K test items for each arm. Write per-item correctness to /tmp/rx-gs1/{arm}/eval.jsonl, and score the paired Hoeffding rule from those files.\n\nActivation-failure plan:\n- (a) Offline first: unit-test compute_advantages in float64 on synthetic rewards. Check forced activation (heterogeneous phi gives nonconstant b_i) and forced nonactivation (huge bandwidth gives b_i equal to the window mean, i.e. a batch-mean REINFORCE baseline). Run gradient checks of the new loop with the treatment disabled against stock cookbook GRPO advantages on one fixed batch.\n- (b) A 2-step treatment pilot logs the gate metrics.\n- (c) If kernel_effective_neighbors fails, the single pre-registered calibration is bandwidth in {0.5, 1.0}, chosen by the gate on pilot training prompts only, never on GSM8K test. The cap is 2 pilot steps and 10 wall minutes.\n- (d) Keep the original failed pilot logs. Any other setting change requires a recorded revised spec before execution. Gates are never relaxed.\n\nNo full run happens while correctness_preflight is unresolved.",
  "correctness_preflight": {
    "paths": [
      {
        "baseline_revision": "UNRESOLVED: pin the tinker-cookbook commit SHA whose rl loop / math_rl group-mean advantage is the stock baseline",
        "id": "gs1_kernel_advantage_loop",
        "kind": "loss",
        "reference_revision": "UNRESOLVED: pin a commit of an independently written float64 numpy reference of the kernel baseline (or the Trajectory reference if released)",
        "tolerances": {
          "baseline_gradient": {
            "atol": 1e-05,
            "min_cosine": 0.99999,
            "rtol": 0.0001
          },
          "baseline_loss": {
            "atol": 1e-06,
            "rtol": 1e-05
          },
          "reference_gradient": {
            "atol": 1e-05,
            "min_cosine": 0.99999,
            "rtol": 0.0001
          },
          "reference_loss": {
            "atol": 1e-06,
            "rtol": 1e-05
          }
        }
      }
    ],
    "required": true,
    "status": "unresolved: the source was not fetched and its kernel is unreleased, so there is no trusted treatment reference; pin revisions and an independent reference before any full sweep"
  },
  "dataset": {
    "hf_path": "openai/gsm8k",
    "n_examples": 2560,
    "name": "gsm8k",
    "split": "main/train"
  },
  "decision_rule": {
    "alpha": 0.05,
    "criteria": [
      {
        "bounds": [
          0,
          1
        ],
        "id": "primary",
        "margin": -0.03,
        "metric": "accuracy",
        "weights": {
          "baseline": -1,
          "treatment": 1
        }
      }
    ],
    "estimand": "Paired difference in GSM8K test exact-match accuracy (GS1 kernel minus GRPO) for these fixed seed-0 final checkpoints; larger is better",
    "method": "paired_hoeffding",
    "seeds": [
      0
    ],
    "unit": "fixed_checkpoint_items",
    "version": 1
  },
  "eval": {
    "aggregation": null,
    "benchmark": "GSM8K test (openai/gsm8k main/test)",
    "metric": "exact-match accuracy, greedy, final checkpoint",
    "n_examples": 1319
  },
  "experiment_features": {
    "adaptive_selection": false,
    "checkpoint_restore": false,
    "custom_loss": true,
    "custom_optimizer": false,
    "generated_training_data": false,
    "heldout_loss": false,
    "learned_generator": false,
    "paired_comparison": true,
    "paired_training_arms": true,
    "warmup_adaptation": false
  },
  "feasibility": {
    "config": null,
    "effective_config": {
      "arms": [
        "grpo_gs8",
        "gs1_kernel"
      ],
      "base_model": "Qwen/Qwen3.5-2B",
      "batch_size": 64,
      "max_seq_len": 1024,
      "max_tokens": 512,
      "n_eval": 1319,
      "steps": 40
    },
    "generation": null,
    "measurements": null,
    "primary_endpoint": "gsm8k_test_exact_match_accuracy_final_checkpoint",
    "recovery": null,
    "source": null
  },
  "feasibility_check": {
    "generation_applicability": {
      "check": "generation_audit",
      "enforce": false,
      "features": {
        "generated_training_data": false
      },
      "reasons": [
        "spec.generation_audit opts out and no feature it covers is true"
      ],
      "status": "not_applicable"
    },
    "generation_counts": null,
    "gpu_hours": null,
    "known_gpu_hours": 0,
    "phases": {},
    "problems": [
      "Effective configuration not recorded",
      "Pilot evidence source not recorded",
      "Representative training timing not recorded",
      "Representative setup timing not recorded",
      "Representative evaluation timing not recorded",
      "Positive recovery reserve not recorded"
    ],
    "status": "unknown",
    "wall_seconds": null
  },
  "feasibility_required": true,
  "generation_audit": {
    "answer_comparison": "numeric_exact",
    "max_eval_overlaps": 0,
    "max_label_errors": 0,
    "min_sample_size": 100,
    "required": false
  },
  "hypothesis": "At 64 rollouts per step for 40 steps on Qwen3.5-2B, GS1 RL with a kernel-weighted cross-prompt baseline is noninferior to GRPO (group_size=8) on GSM8K test exact-match accuracy. The noninferiority margin is 3 points.",
  "lora_rank": 32,
  "max_seq_len": 1024,
  "method": "Both arms train a rank-32 LoRA on Qwen/Qwen3.5-2B from the same base. They use one client-side RL loop built on the tinker-cookbook rl loop, with the stock importance_sampling loss and AdamW. The prompts come from GSM8K train with the stock math_rl renderer and the verifiable exact-answer reward. Each step uses 64 rollouts, max_tokens=512 and temperature 1.0.\n\nThe arms differ only in the advantage estimator:\n- GRPO baseline: 8 prompts x 8 rollouts. Advantage = reward minus group mean, matching the cookbook's default.\n- GS1 treatment: 64 distinct prompts x 1 rollout. Advantage = r_i minus b_i. Here b_i is a kernel-weighted mean of rewards from other prompts in a sliding window of the last 256 rollouts. The window covers the current batch excluding i, plus the previous steps.\n\nThe kernel is fixed before running: a Gaussian kernel exp(-||phi_i - phi_j||^2 / (2*0.5^2)) on a 2-d standardized prompt feature phi = (log prompt-token length, sampling-policy mean token logprob of the prompt). The prompt logprob is computed by the sampling client before rollout. If kernel mass is below 1e-3, the estimator falls back to the window mean.\n\nThe Trajectory post could not be fetched and does not release its kernel, so this kernel is our own pre-registered choice and not the paper's exact method. Kernel hillclimbing, FlashREINFORCE, the trained-critic comparison and cross-task transfer are out of scope for this first node. Each is a follow-up spec.\n\nThe shared Spindle is enough; no fork is needed. Evaluation is greedy decoding on the full GSM8K test split (1319 items), scored by exact match, for the final checkpoint of each arm.",
  "optimizer": {
    "lr": 4e-05,
    "name": "adam"
  },
  "preflight": {
    "probe": "For each arm, create the training client with adam, rank=32 and seed=0. Run one forward_backward with loss_fn='importance_sampling' on one sampled GSM8K example carrying that arm's computed advantage, then one optim_step(tinker.AdamParams(learning_rate=4e-5)). Confirm both succeed and the loss is finite. Then run the offline advantage unit tests and the 2-step activation pilot.",
    "riskiest_assumption": "The custom GS1 advantage path is correct and engages. Specifically, the new loop reproduces stock GRPO advantages when the treatment is disabled, and the kernel baseline gives a nonconstant, reward-predictive b_i. Otherwise a GS1-vs-GRPO gap reflects bugs or a degenerate batch-mean baseline, not the method.",
    "tuning": "Both arms use the same optimizer (AdamW) and a fixed LR of 4e-5 taken from cookbook math_rl defaults for small Qwen models. There is no per-arm grid, because the hypothesis concerns the advantage estimator at a fixed recipe. An LR-sensitivity follow-up would give each arm a 3-value grid selected on a GSM8K train holdout, with the grid-edge rule applied."
  },
  "primary_endpoint": "gsm8k_test_exact_match_accuracy_final_checkpoint",
  "restoration_preflight": {
    "applicable": true,
    "fixed_batch_required": true,
    "groups": [
      {
        "arms": [
          {
            "name": "grpo_gs8",
            "optimizer": "adam",
            "optimizer_config": {
              "beta1": 0.9,
              "beta2": 0.95,
              "eps": 1e-08,
              "lora_rank": 32,
              "lr": 4e-05,
              "seed": 0
            }
          },
          {
            "name": "gs1_kernel",
            "optimizer": "adam",
            "optimizer_config": {
              "beta1": 0.9,
              "beta2": 0.95,
              "eps": 1e-08,
              "lora_rank": 32,
              "lr": 4e-05,
              "seed": 0
            }
          }
        ]
      }
    ],
    "reason": "Both trained arms start from the same base LoRA initialization within seed 0."
  },
  "spec_preflight": {
    "findings": [],
    "status": "passed"
  },
  "steps": 40,
  "success_criterion": "GS1 minus GRPO GSM8K test exact-match accuracy, as a lower 95% Hoeffding bound over 1319 paired items, must exceed -0.03 (noninferiority margin of 3 points). If the interval straddles -0.03, the pilot is inconclusive and is not counted as a win.",
  "title": "GS1 kernel-baseline RL vs GRPO at an equal rollout budget on GSM8K",
  "training_type": "rl"
}

pilot_mean_reward_treatment

-0.0375

kernel_effective_neighbors_p10

7.877

frac_nonzero_advantage_treatment

0.9922

baseline_reward_corr

-0.1174

executed_group_size_treatment

1

executed_group_size_baseline

8

pilot_frac_truncated_512_treatment

1

• code_revision · code-revision.txt
• effective_config · effective-config.json

1. Nov 4, 15:40 UTC · failed · Correctness preflight passed on shared Spindle with Qwen3.5-2B: errors were exactly 0, and both arms loaded one shared init checkpoint and gave identical initial outputs. The 2-step activation pilot …
2. Nov 4, 15:25 UTC · running · Preflight running on shared Spindle (Qwen/Qwen3.5-2B served). Server rejected per-model seed=0 at LoRA creation, so both arms load one shared saved init checkpoint instead.

correctness_preflight

{'required': True, 'paths': [{'id': 'gs1_kernel_advantage_loop', 'fixed_input': {'sha256': '82ae1c65eb2e6c6eb2027cc8548b1f6a7bc1a2535cf81e30a481329aed65ddec', 'description': 'Baseline fixture: 8 GSM8K train prompts x 8 rollouts sampled from the shared init checkpoint, built into 64 Datums (sha is over token ids, targets, sampling logprobs and advantages). Reference fixture: 64 prompts x 1 rollout with the same features; Datum sha 0719ffb3a349bcc7d2f09849c088129aff67b2a7bf5761b5b540fc4e86734d72. The optimizer state was fresh.'}, 'baseline_revision': 'tinker-cookbook f79fdb2ba4cd967ef2807ba43097c52985f9f17f (rl/data_processing.compute_advantages + assemble_training_data)', 'reference_revision': 'kernel_ref.py sha256 05260a665e81217716cd09896a2780903a0c018ff4acf132ceda4348df8eea05 (independent float64 loop reference, local commit 07992e6)', 'implementation_revision': 'local git c0874243760634e91cf598e154e494368ab476bd (gs1_kernel.py sha256 9237736f...; rx_gs1.py a1628233...)', 'precision': "float64 advantages, cast to float32 in the Datum (as the cookbook does); server forward in bf16; loss and gradient recomputed in float64 from a single server forward's logprobs", 'normalization': 'importance_sampling summed over action tokens (mask = action tokens, prompt advantage 0); no per-token mean; the gradient is d loss / d target-token logprob = -adv*exp(lp - sampling_lp); no update or rank scaling', 'errors': {'baseline_loss': {'max_abs_error': 0.0, 'reference_max_abs': 0.021621108899012143, 'relative_l2_error': 0.0, 'cosine_similarity': 1.0}, 'baseline_gradient': {'max_abs_error': 0.0, 'reference_max_abs': 1.001115644955279, 'relative_l2_error': 0.0, 'cosine_similarity': 1.0}, 'reference_loss': {'max_abs_error': 0.0, 'reference_max_abs': 220.2439328146869, 'relative_l2_error': 0.0, 'cosine_similarity': 1.0}, 'reference_gradient': {'max_abs_error': 0.0, 'reference_max_abs': 1.2453616086729702, 'relative_l2_error': 0.0, 'cosine_similarity': 1.0000000000000002}}, 'lr_scaling': []}]}

correctness_validation

{'status': 'unverified', 'required': True, 'checks': [{'path': 'gs1_kernel_advantage_loop', 'check': 'baseline_loss', 'status': 'passed', 'tolerance': {'atol': 1e-06, 'rtol': 1e-05}, 'measured': {'max_abs_error': 0.0, 'reference_max_abs': 0.021621108899012143, 'relative_l2_error': 0.0, 'cosine_similarity': 1.0}}, {'path': 'gs1_kernel_advantage_loop', 'check': 'baseline_gradient', 'status': 'passed', 'tolerance': {'atol': 1e-05, 'rtol': 0.0001, 'min_cosine': 0.99999}, 'measured': {'max_abs_error': 0.0, 'reference_max_abs': 1.001115644955279, 'relative_l2_error': 0.0, 'cosine_similarity': 1.0}}, {'path': 'gs1_kernel_advantage_loop', 'check': 'reference_loss', 'status': 'passed', 'tolerance': {'atol': 1e-06, 'rtol': 1e-05}, 'measured': {'max_abs_error': 0.0, 'reference_max_abs': 220.2439328146869, 'relative_l2_error': 0.0, 'cosine_similarity': 1.0}}, {'path': 'gs1_kernel_advantage_loop', 'check': 'reference_gradient', 'status': 'unverified', 'tolerance': {'atol': 1e-05, 'rtol': 0.0001, 'min_cosine': 0.99999}, 'measured': {'max_abs_error': 0.0, 'reference_max_abs': 1.2453616086729702, 'relative_l2_error': 0.0, 'cosine_similarity': 1.0000000000000002}}], 'reason': 'gs1_kernel_advantage_loop: matching reference_revision; gs1_kernel_advantage_loop: matching baseline_revision; gs1_kernel_advantage_loop: reference_gradient cosine/tolerance', 'evidence_source': 'executor report; remote execution is not attested', 'applicability': 'required', 'reported_verdict': 'inconclusive'}

decision_validation

{'status': 'uncertain', 'issues': ['Decision evidence was not recorded.'], 'criteria': [], 'outcome_reason': 'insufficient_evidence', 'unit': 'fixed_checkpoint_items', 'n_seeds': 1, 'alpha': 0.05, 'method': 'paired_hoeffding', 'applicability': {'check': 'decision_rule', 'status': 'required', 'enforce': True, 'reasons': ['experiment_features: paired_comparison is true'], 'features': {'paired_comparison': True, 'adaptive_selection': False}}}

feasibility

{'status': 'unknown', 'problems': ['Re-projection required: base_model changed or was not recorded', 'Re-projection required: lora_rank changed or was not recorded', 'Re-projection required: dataset changed or was not recorded', 'Re-projection required: steps changed or was not recorded', 'Re-projection required: max_seq_len changed or was not recorded', 'Re-projection required: n_examples changed or was not recorded', 'Re-projection required: n_eval changed or was not recorded', 'Representative evaluation timing not recorded'], 'wall_seconds': None, 'gpu_hours': None, 'known_gpu_hours': 0, 'phases': {'setup': {'wall_seconds': 146.0, 'planned_units': 1, 'planned_samples': 0.0, 'gpu_hours': None}, 'training': {'wall_seconds': 2462.0, 'planned_units': 80, 'planned_samples': 5120.0, 'gpu_hours': None}, 'recovery': {'wall_seconds': 900, 'gpu_hours': None}}, 'generation_counts': None, 'generation_applicability': {'check': 'generation_audit', 'status': 'not_applicable', 'enforce': False, 'reasons': ['spec.generation_audit opts out and no feature it covers is true'], 'features': {'generated_training_data': False}}, 'record': {'config': {'base_model': 'Qwen/Qwen3.5-2B', 'arms': ['grpo_gs8', 'gs1_kernel'], 'steps': 2, 'batch_size': 64, 'max_tokens': 512, 'n_eval': 0}, 'effective_config': {'base_model': 'Qwen/Qwen3.5-2B', 'arms': ['grpo_gs8', 'gs1_kernel'], 'steps': 40, 'batch_size': 64, 'max_tokens': 512, 'max_seq_len': 1024, 'n_eval': 1319}, 'primary_endpoint': 'gsm8k_test_exact_match_accuracy_final_checkpoint', 'source': 'pilot_gs1_kernel/steps.jsonl, pilot_grpo_gs8/steps.jsonl', 'measurements': {'setup': {'seconds': 146.0, 'units': 1, 'planned_units': 1, 'samples': 0, 'gpu_count': None, 'allocation_source': None}, 'training': {'seconds': 123.1, 'units': 4, 'planned_units': 80, 'samples': 256, 'gpu_count': None, 'allocation_source': None}}, 'generation': None, 'recovery': {'seconds': 900, 'gpu_count': None, 'allocation_source': None}}, 'recorded_at': 1793806816.0102577}

feasibility_required

True

generation_audit_validation

{'status': 'not_applicable', 'reasons': ['spec.generation_audit opts out and no feature it covers is true'], 'applicability': {'check': 'generation_audit', 'status': 'not_applicable', 'enforce': False, 'reasons': ['spec.generation_audit opts out and no feature it covers is true'], 'features': {'generated_training_data': False}}}

initialization_provenance

{'version': 1, 'arms': {'grpo_gs8': {'initialization': {'base_checkpoint': 'Qwen/Qwen3.5-2B', 'checkpoint_uri': 'tinker://09950f53d8f9d5a7e24607f09804e8c3/weights/rx-shared-init', 'checkpoint_immutable': True, 'checkpoint_scope': 'full_initialization', 'loaded_checkpoint_uri': 'tinker://09950f53d8f9d5a7e24607f09804e8c3/weights/rx-shared-init', 'load_succeeded': True, 'adapter_sha256': None, 'source': 'server_response', 'evidence_ref': 'pilot_grpo_gs8/steps.jsonl', 'before_first_update': True}, 'restore_count': 1, 'optimizer_checks': [{'after_restore': 1, 'before_next_update': True, 'requested': 'adam lr 4e-5 b1 0.9 b2 0.95 eps 1e-8', 'actual_family': 'adamw', 'actual_config': "GetInfoResponse.optimizer_config=AdamOptimizerConfig(type='adamw'); hyperparameters are passed per optim_step via AdamParams", 'source': 'server_response', 'evidence_ref': 'pilot_grpo_gs8/steps.jsonl'}], 'initial_output': {'available': True, 'batch_sha256': '8f59140cac1ac5353e296cc0beed975c2e1c6fd22752ffa00dae356c7593ade1', 'output_sha256': 'ddc7433903e463134f86d48f6ed82b48f28ee20a844ce61ccbbed9cdb0b8f004', 'evidence_ref': 'pilot_grpo_gs8/steps.jsonl', 'before_first_update': True}}, 'gs1_kernel': {'initialization': {'base_checkpoint': 'Qwen/Qwen3.5-2B', 'checkpoint_uri': 'tinker://09950f53d8f9d5a7e24607f09804e8c3/weights/rx-shared-init', 'checkpoint_immutable': True, 'checkpoint_scope': 'full_initialization', 'loaded_checkpoint_uri': 'tinker://09950f53d8f9d5a7e24607f09804e8c3/weights/rx-shared-init', 'load_succeeded': True, 'adapter_sha256': None, 'source': 'server_response', 'evidence_ref': 'pilot_gs1_kernel/steps.jsonl', 'before_first_update': True}, 'restore_count': 1, 'optimizer_checks': [{'after_restore': 1, 'before_next_update': True, 'requested': 'adam lr 4e-5 b1 0.9 b2 0.95 eps 1e-8', 'actual_family': 'adamw', 'actual_config': "GetInfoResponse.optimizer_config=AdamOptimizerConfig(type='adamw')", 'source': 'server_response', 'evidence_ref': 'pilot_gs1_kernel/steps.jsonl'}], 'initial_output': {'available': True, 'batch_sha256': '8f59140cac1ac5353e296cc0beed975c2e1c6fd22752ffa00dae356c7593ade1', 'output_sha256': 'ddc7433903e463134f86d48f6ed82b48f28ee20a844ce61ccbbed9cdb0b8f004', 'evidence_ref': 'pilot_gs1_kernel/steps.jsonl', 'before_first_update': True}}}, 'note': 'Adapter bytes are not downloadable for non-external checkpoints, so adapter_sha256 is null and the proof rests on the shared immutable checkpoint URI plus identical full-precision initial logprob hashes. The after_restore=0 creation check does not apply: arms are created directly from state.'}

launch

{'experiment_id': 'exp_32150a771c', 'context_status': 'snapshotted', 'superseded': False, 'mode': 'redo', 'purpose': "Repeat the selected saved experiment version to check reproducibility. This repetition tests that version's hypothesis and methods."}

progress_updated_at

1793806791.408849

reported_outcome_reason

incomplete_execution

reported_verdict

inconclusive

restoration_validation

{'status': 'unverified', 'required': True, 'checks': [{'check': 'grpo_gs8', 'status': 'unverified', 'reason': 'grpo_gs8: missing or duplicate arm evidence.'}, {'check': 'gs1_kernel', 'status': 'unverified', 'reason': 'gs1_kernel: missing or duplicate arm evidence.'}], 'reason': 'grpo_gs8: missing or duplicate arm evidence.', 'applicability': 'required'}

slack_started

True

started_at

1793805506.6316648

verdict_report

{'margin': -0.03, 'seeds': 1, 'reasoning': 'The activation gate failed before full training, so the GS1-vs-GRPO effect was never measured. The renderer is the Qwen3.5 thinking-mode default (qwen3_5). With it, 95-100% of rollouts hit max_tokens=512 before writing a boxed answer, so the reward is near-constant at -0.1 and the kernel baseline cannot predict per-prompt reward.'}