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