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. Any future candidate must pass both its own gate and every unchanged prior-task gate. Adding a capability is not permission to forget the previous one.
3. No private data. The current task set is generated locally from fixed seeds. It contains no private conversations, repository history, or unpublished personal data.

View data table

Cumulative curriculum lineage: nodes

Node	Detail	Stage
Raw base model	Qwen3.5-35B-A3B-Base	1
Task set 1	flat JSON transformation	2
Promotion gate 1	development + sealed test	3
Promoted adapter	task-set-1 checkpoint	4

Cumulative curriculum lineage: edges

From	To	Relationship
Raw base model	Task set 1	train
Task set 1	Promotion gate 1	evaluate
Promotion gate 1	Promoted adapter	passes

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 currently published experiment has one task set:

• 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.

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.

Evidence limits

The experiment is an engineering specimen, not a research benchmark. Task set 1 is a narrow, deterministic code-generation task evaluated by a restricted interpreter. Its result demonstrates learning inside that fixed grammar; it does not establish general coding ability or a universal continual-learning method. The task-set page documents the complete gate and evidence limits.