Tinker curriculum

The Tinker curriculum is a standalone experiment in cumulative agent training. It teaches a raw language model one closed task set at a time, measures each independently against a sealed promotion gate, and does not add another task set until the first one clears its gate. The project is designed so that capability growth cannot silently erase prior behavior: every future task-set addition must preserve and rerun the earlier frozen evaluations.

The experiment uses Tinker, a hosted training and sampling service for fine-tuning large language models. The base model is Qwen3.5-35B-A3B-Base, a 35-billion-parameter mixture-of-experts model with approximately 3 billion active parameters per token. Training uses LoRA (low-rank adaptation), a parameter-efficient fine-tuning method that trains a small adapter on top of frozen base weights rather than modifying the full model.

Design principles

The curriculum follows three rules that distinguish it from open-ended fine-tuning:

1. One task set at a time. A task set is a bounded capability family with explicit training, development, and held-out evaluation sets. No later task set is added until the previous one passes its gate.
2. Cumulative retention. A candidate adapter for task set 2 must pass both its own gate and the unchanged task-set-1 gate. Adding a capability is not permission to forget the previous one.
3. No private data. Task set 1 is generated locally from fixed seeds. Task set 2 is original, source-backed paraphrase of public historical material. Neither contains private conversations, repository history, or unpublished personal data.

Cumulative curriculum lineage. Each candidate inherits the previously promoted adapter, adds one bounded task family, and must pass both its new gate and every frozen retention gate.

Source: Tinker curriculum public lineage receipts and promotion contracts. Note: Task set 2 is an experimental engineering acceptance result because its prompt contract was repaired after an initial held-out failure.

The orchestration rule can be summarized without depending on one training platform:

candidate = train(parent=promoted_adapter, data=current_task + replay(previous_tasks))

if current_gate(candidate) and all(retention_gate(candidate, task) for task in previous_tasks):
    promote(candidate)
else:
    preserve_receipt_and_reject(candidate)

Task sets

The project has two task sets. Each has its own standalone page:

• Flat JSON transformation teaches the model to emit a single Python function that transforms a flat record according to a natural-language instruction. A narrow AST interpreter evaluates the generated code against hidden cases rather than executing it as arbitrary Python.
• Tiananmen history continuation continues from the promoted task-set-1 checkpoint and teaches source-backed question-answering about the 1989 Tiananmen protest movement. It is labeled as an experimental curriculum adapter with iterative benchmark development, not a clean benchmark result.

Promotion contract

Each task set has a promotion contract that must be satisfied before its held-out split is opened. The contract requires a minimum accuracy threshold, a minimum improvement over the parent model, and—when a prior task set exists—retention of the earlier capability. Task set 1 followed that contract cleanly. Task set 2 later required a prompt-contract repair after its first held-out invocation, so its final result is an exploratory engineering acceptance test rather than a clean sealed evaluation.

Evidence limits

The experiment is an engineering specimen, not a research benchmark. Task set 2 was developed iteratively against observed model behavior, its evaluator was revised during the same session as training, and the sampling service produced non-identical outputs across nominally temperature-zero calls. The reported results are engineering acceptance receipts, not pre-registered or statistically stable estimates. These limits are documented in detail on each task-set page.

Sources

• Tinker
• Qwen3.5-35B-A3B-Base on Hugging Face
• LoRA — Low-Rank Adaptation of Large Language Models