Dataset Viewer
Auto-converted to Parquet Duplicate
Search is not available for this dataset
steps
int64
tokens
int64
tokens_per_s
int64
tflops
float64
mfu_pct
float64
peak_gb
float64
elapsed_s
float64
data_requirement
dict
gpu
dict
18
2,359,296
107,115
209.8
51.7
84.07
22
{ "tokens_per_s": 107115, "screens_per_s": 194.8, "screens_per_hour": 701116, "tokens_per_12h_session": 3701894893 }
{ "util_pct": 55.9, "util_max": 100, "mem_used_mb": 89526, "power_w": 512, "samples": 39 }

WINCLAW

An agentic harness, and the model built from random init to be its core.

No pretrained weights. No third-party model. No external agent framework. The environment, its labels, the font, the tokenizer, the architecture and the checkpoint protocol are all built here, in a Molab sandbox, one 12-hour session at a time. The only things imported are the world: the English language, real desktop pixels, and real task semantics.

Status - honest, no results claimed yet

part state
GlyphForge font engine, 95 glyphs, own rasterizer working, verified against rendered output
Corpus doctrine + contamination guard + licence ledger working
Continuum checkpoint / resume / provenance protocol working, this commit is its first push
Rasteron - our own GPU UI rasterizer not started
WinSim - window manager, apps, dialogs not started
ActLang + our own BPE tokenizer not started
Winclaw-0-150M - the model architecture defined, no weights yet
Harness, task suite, Verdict evaluator not started

Nothing above is a claim of results. It is a claim of provenance: every artifact here can be traced to the code and the session that produced it.

The inversion

People train a general multi-function model and then put it inside an agentic harness. WINCLAW is the inverse: the harness interface is fixed first, and the model is trained from random init against it. The model is not a component inside a harness - it is the harness core.

That buys four things: no interface tax (the observation format and action space are the pretraining distribution), exact labels instead of judge models, an architecture matched to the action space, and a small model with a real chance against a large one.

It costs one big thing: generalisation. A general model arrives with open-world priors; a control-only model only knows the distribution we generated. We optimise for interface fidelity and pay in generalisation - which is only the right bet because we own the labels.

The boundary that makes a 150M model viable is enforced in code (winclaw/boundary.py): the model owns intent, the harness owns mechanics, and deterministic work is never assigned to weights. 6 decisions go to the model, 7 to the harness, 2 are shared, and the audit rejects any assignment that asks the weights to do arithmetic, verification or safety.

The falsifiable claim

A 150M parameter model trained from random init, solely to control, beats a general multi-function model 5-10x larger on Windows control, under the same harness, on a held-out task suite it never trained on.

Honest precedent: the pattern is proven where the environment is owned - game agents and robotic control policies are trained for control alone against simulators they own. What has not been done is applying it to a general-purpose desktop OS, with the simulator, font, action grammar, tokenizer, architecture and checkpoint protocol all built from nothing in one stack.

Repositories

repo holds
winclaw-harness the notebook (control plane), the package, docs, session logs, sync manifests
winclaw-0-150m model: pretrain/ sft/ dpo/ grpo/ gguf/, one manifest + pointer per stage
winclaw-corpus corpus registry, licence ledger, generated shards
winclaw-tasks task suite, success checkers, Verdict results

The doctrine

The distinction that matters is not ours vs theirs. It is:

  • generate - the environment, its labels, transitions and success signals. Nobody has these for Windows, and owning them is what makes from-scratch training work.
  • import - the world we must operate in: English, real desktop pixels, real task semantics. Refusing these does not make us pure, it makes us blind.
  • never - other people's weights, other agents' labels treated as ground truth, and anything we evaluate on. Contamination is refused in code, not promised in prose.

Design status

Completeness is a checklist, not a feeling: winclaw/design.py holds a 22-item register with a done-criterion and a dependency for each, and the register audits its own completeness. It currently reports 100.0% - 22 of 22 items specified or verified - with 15/16 spec audits passing.

Specified is not built. The modules are executable specifications with audits, not working systems. What exists in the register is the design, its budgets, its schemas and its self-limits - including a vertical-slice audit that fails if the slice grows too large for one session, and a roadmap that says release is 62 sessions away rather than eight.

Known defects

This project audits its own design in the open, and the audit is not flattering: winclaw/audit.py records 16 findings, 4 of them blockers, 6 of them proved by running the code rather than reading it. The headline ones: nothing end-to-end has ever run; from-scratch removes exactly the priors that bridge simulation to reality; the generated corpus cannot be stored and so depends on unverified GPU determinism across sessions; and the declared model context is 2.6x too small for its declared observations. Read the audit before trusting any claim in this repository.

The invented stack

GlyphForge (glyphs, metrics, rasterizer) -> Rasteron (GPU UI rasterizer) -> WinSim (window manager, apps) -> UiaLite (state schema) -> ActLang (action grammar + tokenizer) -> Winclaw-0 (own architecture, random init) -> harness -> Verdict (eval) -> Continuum (checkpoints).

Sessions

Every session is 12 hours in a fresh sandbox. RESUME.md is the operational protocol; winclaw/continuum.py is its implementation.

Downloads last month
116