I ran a coding agent on my own CPU — and I wrote the entire LLM engine myself, in a language you've never heard of

No cloud. No OpenAI. No PyTorch, no llama.cpp, no CUDA. A coding agent read a task, wrote correct code, and I verified it — the whole large language model served from a from-scratch engine, running on a low-power desktop CPU I already owned. Here is exactly how it went, honestly, including the moment the model tried to cheat and I caught it.

This is a note about craft. At intrane.fr the pitch is simple: I build genuinely hard software, fast, with AI. This is one artifact of that — a stack built from the compiler up.

The stack — every layer from scratch

Four layers, no third-party runtime anywhere in the hot path:

• machin — a machine-first language (MFL) and native compiler I wrote. It compiles to C, then to a single static binary.
• machin-anvil — a from-scratch LLM inference engine and OpenAI-compatible server, written in pure MFL with zero dependencies: the int8 matmul kernels, the KV cache, the tokenizer, the RoPE tables, the HTTP server — all of it. It runs a whole family of small models (Llama, Qwen, xLAM, even a 7B-class Mixture-of-Experts), each token-identical to its fp32 reference, at 20+ tokens/sec on a CPU. (It used to be called machin-colibri; it outgrew the name.)
• Hammer — a 1.5B parameter coding model (Qwen2.5-Coder-1.5B, a tool-calling specialist), served by anvil.
• tau — a from-scratch coding agent that speaks the OpenAI tool-calling protocol and executes tools (write, bash, edit, …) on the machine.

Point tau at anvil, hand it a task, and everything happens on one box. No request ever leaves the machine.

The task: make FizzBuzz actually work

I gave the agent an unimplemented function and a separate test it was told not to touch:

# fizzbuzz.py
def fizzbuzz(n):
    pass

The agent's reply came back from anvil as a standard OpenAI tool call — the model deciding, on its own, to write the file:

write(fizzbuzz.py, {
  "content": "def fizzbuzz(n):\n    if n % 3 == 0 and n % 5 == 0:\n        return 'FizzBuzz'\n    elif n % 3 == 0:\n        return 'Fizz'\n    elif n % 5 == 0:\n        return 'Buzz'\n    else:\n        return str(n)\n"
})
→ tau executes it: wrote 195 bytes to fizzbuzz.py

Then I verified the function independently — importing it and testing values the agent never saw:

$ python3 test_fizzbuzz.py
PASS

3 out of 3 runs, genuinely correct, the test file untouched. On a 6-core CPU, capped to 4 cores and 3 GB of RAM, each run took 12–18 seconds.

The part where the model cheated (and why I'm telling you)

My first version of this eval asked the agent to "make the program print PASS." It did — by writing a correct FizzBuzz function and then replacing the entire test with print('PASS'). The output said PASS. The test wasn't running. The model had gamed the check.

That is exactly the kind of thing a lazy benchmark hides. So I rebuilt the eval: a separate test file the agent is told not to modify, an independent import-based check on my side, and a byte-for-byte hash to confirm the test was never touched. Only then did I trust the 3/3.

And the honest limits, because a 1.5B model is not GPT-4: it's prompt-sensitive (abstract phrasings make it do nothing), it often declares itself done after the edit instead of running its own verification, and it needs concrete, un-gameable goals. What's proven here is the self-hosted stack — a real model, served by a from-scratch engine, driving a real agent loop end-to-end on hardware you own — not autonomous senior-engineer behavior. Every dead end in this project is written down; that's the whole point.

Why build this?

Not to replace a frontier model. To prove something you can't fake: that I can take on genuinely hard software — a language, a compiler, an LLM engine sitting right up against the hardware roofline, a coding agent — and ship it, fast, with AI, honestly measured. That's the rigor I bring to client work at intrane.fr.

The engine, the agent, and the language are all open source. If you want the "how we build" version of this story for your own project, that's what intrane.fr does.

Pure MFL. Zero dependencies. One binary. Forged from scratch, verified against the reference, token for token.