mohith
← All writing

Teaching Inkling to stop overthinking

Post-training Inkling 2 Small on Tinker cut mean output tokens from 3,109 to 74 on a pixel-art task. What SFT improved, what it did not, and why the next stage stopped.

I post-trained Inkling 2 Small on Tinker to draw pixel art without spending most of its output budget thinking. In a locked evaluation of 100 generated icons, mean output tokens fell from 3,109 to 74, finish rate rose from 49% to 99%, and faithful drawings rose from 40% to 68%.

Those gains came from supervised fine-tuning (SFT). Shorter drawing programs and the next training stage were different stories.

The task: draw, then finish

I wanted a model to look at pixel art and return a small drawing program. The task was deliberately concrete: reproduce a target on a 32×32 canvas with rect, line, circle and px commands. A NumPy renderer could compare every output pixel with the target. There was no LLM judge, and model output was parsed rather than executed.

The strong prompt already asked the model to think briefly, avoid explanations and answer in a single fenced pixel block. It included a generated worked image/program pair and the target image. The target was enlarged with nearest-neighbour interpolation to 256×256 for the model, while scoring stayed on the original canvas.

The baseline still frequently ran out of output budget before finishing. That made finishing and faithful drawings the main questions. Drawing-command compression was a separate, secondary question.

Sources: prompt, prompt construction, protocol.

The Tinker setup

The base model was thinkingmachines/Inkling-2-Small. I used Tinker and the cookbook's supervised image-training loop, with Python driving the experiment.

The artwork and reference programs were generated in code. The training families were spaceship, mushroom, robot, house, tree and fish; duck and cactus were held out. The locked test set contained 100 icons spanning new instances, changed palettes/positions and held-out families. Geometry and image hashes were checked across the data splits.

The recorded SFT configuration was:

SettingValue
LoRA rank8
Learning rate0.0001
Batch size32
Epochs1
Model effort0.0
Maximum output tokens4,096

SFT targets contained only the generator's fenced drawing program and its stop boundary, without reasoning text. The loss targeted the last assistant message. The strong input prompt stayed the same for base and SFT evaluation.

The preflight selected a family-balanced training subset based on its token price while reserving budget for evaluation. The code saved a final training state and exported its sampler for the locked comparison; this was not a test-set checkpoint search. Service runs were guarded by budget and storage checks.

Sources: configuration, SFT implementation, preflight record.

What worked

On the same locked evaluation, the headline results were:

MetricBaseSFT
Mean output tokens, including reasoning3,10974
Finished within the output cap49%99%
Faithful drawings40%68%

The token counts are rounded means, not medians and not latency measurements. The useful change was that the model more often returned a finished drawing with much less output overhead.

“Faithful” meant at least 95% exact pixel agreement. Unparseable programs scored zero; failures stayed in the all-icon denominators. The comparison used deterministic outputs, and the result is a single generated-art pilot, not a claim about every drawing task.

The public demo replays actual saved programs. Its stroke-by-stroke playback is a way to inspect commands, not a measurement of inference speed. It includes failures as well as successes, so a selected GIF should not stand in for the pooled result.

Sources: results and intervals, saved-result demo, numeric provenance.

What did not improve

The original goal included shorter drawing programs. That result did not materialize in the paired comparison: median command counts were unchanged on the icons that both models drew faithfully. Less output text did not mean fewer drawing commands.

Generalization was uneven too. Only 37.5% of SFT outputs on held-out palettes and positions were faithful. A program could finish and still put the wrong colours or geometry on the canvas.

This distinction matters: learning to return the required answer format is useful, but it does not establish that the visual task is solved.

Source: paired command-count and per-stratum results.

Why the next stage stopped

The planned next stage could use cookbook GRPO if service and storage constraints allowed it, or fall back to reward-selected SFT. The implemented fallback sampled candidate programs and checked their rewards before any further fitting.

That check stopped the run. Every candidate group returned token-identical samples, leaving zero reward variance within each group. No reward-selected fitting occurred, and there is no incremental RL or RS-SFT effectiveness result to report.

A shared fixed seed was present in those calls. The audit did not isolate its causal role with a varied-seed control, so “the seed caused it” would be stronger than the evidence supports. The supported conclusion is that the intended independent candidate search was invalid. It is not evidence that the model had saturated.

The deterministic base/SFT comparison remains usable. The independent multi-candidate diagnostics do not. The later audit confirmed that no further fitting occurred.

Sources: sampling-diversity audit, stop record, candidate-selection implementation.

What I would test next

Before another training stage, I would amend the seed strategy and check candidate diversity on development inputs. I would then reprice genuinely independent samples before authorizing another paid round. Those are proposed next steps, not completed experiments.

For the drawing task itself, the palette/position failures need separate attention. I would keep format compliance, completion, pixel fidelity and paired command counts as separate checks, rather than letting a smaller token count stand in for all of them.

Pixel Miser taught the model to finish this task with much less output. It did not demonstrate command compression, solve every held-out drawing, or establish an RL improvement.

Repository · Original thread