Notes on .NET, XAF, and building things
Twenty years of XPO, application frameworks, and lately a lot of applied AI. 336 articles and counting.
Browse by topic
All topics →Latest articles
View all →
Microsoft Just Shipped Jev's API: Microsoft-Decision-1 vs Jev, Tested From C#
On 9 October Microsoft put Microsoft-Decision-1 into Foundry: a System One model that picks instead of writing, at exactly Jev's price. The surprising part isn't the model, it's the wire format. It serves Jev's System One API field for field, so one C# client now talks to Jev, to Microsoft, and to a free local open-jev. I ran 48 labeled support tickets through Decision-1 and open-jev, hit five Foundry traps on the way, and found a bug in my own earlier Jev client.
Can a small model learn a programming language nobody has ever seen?
Every time a small model writes clean code, there's a question behind it: did it learn that, or just remember it from training? So I built an experiment where remembering is impossible — I invented a .NET language called Kite.NET, gave it a compiler, and taught a 1.5B model to write it. Before training it passed 0% of the exam; after, 69.4%, on kinds of problems it had never seen.
Designing Kite.NET
Kite.NET had to be three things at once: new (no model could have seen it), visibly not C# (so a fallback is obvious to me and the compiler), and small but real enough to run on .NET. This is a tour of the language that came out — records, pipes, when-matching, let vs let mut — and every example compiles and runs.
Compiling a made-up language to .NET
A made-up language needs a compiler before any model can learn it, because the compiler is what grades every answer. Here's the one decision that shaped everything: how to get a new language onto .NET. I went through Roslyn with #line markers — the same trick Razor uses — to keep the .NET analyzers and point every error back at the Kite source.
A grader that can't be fooled
The whole experiment rests on one thing: every answer graded by a machine, the same way every time. This is the four-layer grader — Kite's own analyzer, the C# compiler, the .NET analyzers, and hidden tests — and the two traps that silently switched parts of it off (a file-name suffix and a two-letter culture code).
More topics
All topics →
Training data that grades itself
To teach a model Kite I needed about 1,500 examples, with nobody reading them by hand. A big model drafts; the compiler decides. A draft is kept only if it compiles with zero warnings and every hidden test passes — and the exam holds out whole kinds of problems, not just individual tasks.
It learned Kite and forgot C#
The first trained model learned Kite and forgot C# — ask it for C#, it wrote Kite. A 'not dumber' guard caught it, and it took three rounds to get a model that learned Kite and kept its C#. This is the story of catastrophic forgetting, two rejected rounds, and the champion that went from 0% to 69.4%.
83 tokens per second on a CPU
A model that only runs on a big GPU isn't much use for a narrow job like 'write code in our language'. This is how Kite's 1.5B model went from trained to fast and portable — merge the LoRA adapter, quantize to GGUF — and ran at 83 tokens per second on a CPU alone, with the quality checked at every step.
What didn't work, and what's next
The headline is good — a 1.5B model went from 0% to 69.4% in a language that didn't exist, kept its C#, and runs at 83 tokens per second on a CPU. This last part is the honest other half: the fix-it loop that fixed nothing real, what I'd change, what's next, and the whole recipe in one place. The repo, compiler, tasks and model files are now public.
The Essay and the Multiple-Choice Exam: How Jev Works vs. a Normal LLM
A normal LLM answers every question the way a student answers an essay: it writes the answer out, one word at a time. Jev answers the way that same student fills in a Scantron: it reads the options and bubbles the best one. That single difference — essay versus multiple-choice — explains why Jev is faster, can't produce malformed output, and gives you a calibrated probability, and it's the clearest way I've found to explain how these 'budget' decision models actually work.