
The lookalike directory that answered for the past
Three scripts measured the same checkpoint and silently read a twin frozen two days back. The path looked right, which is why nobody doubted it.
32 posts

Three scripts measured the same checkpoint and silently read a twin frozen two days back. The path looked right, which is why nobody doubted it.

Sixteen coherence checks passed, the gap between CPU and GPU sat in the billionths, and the engine still produced nonsense. The defect only surfaced when a second engine, written by somebody else, read the same model file. A test that compares a system to itself always agrees.

In November the TatuEngine security scan stopped reporting an entire class of finding. Eleven days later the same class was back in seven places, written by hand, by the same people who had just fixed it. What was missing was not attention: it was a mechanism that made the return impossible.

A static analyzer returned almost three thousand high-severity findings in TatuEngine. Nearly all of them were the same test line repeated. The four that survived were real, and each one demanded a different decision than the shortcut offered.

Every check came out approved. Not because the system was right, but because the runner wrote PASS on the report before looking at the result. The defect stayed invisible for weeks: a gate that always agrees is not a gate, it is a rubber stamp.

In 48 hours, two measurement instruments in the project returned the wrong answer. One listed a third of what existed by sorting text as text. The other fabricated a number where data was missing. The cure for both was the same.

A technical post-mortem of how we replaced TatuEngine's weight format with ternary blocks and got the model back inside consumer GPU memory, without losing inference coherence.

The agent cycle ran end to end for the first time — after three integration failures that died in silence and a training setup that learned to measure two runs from the same starting point.

The two meters that evaluated format and internal dynamics in TatuEngine lived on a disk that stopped existing during the migration. Training kept running on perplexity alone — until the ruler was rebuilt and returned an uncomfortable number: format hit 100%, accuracy never left the noise.

The C arm sat at 0% of the dataset because its corpus lived on a path the migration had erased. When the campaign ran again, the manifest reported 766 pairs — and the per-teacher count reported something else: 96.9% of a single lane.

Run 2 proved that TatuEngine learned Portuguese and forgot English. The next two runs proved something else: I was measuring that forgetting on a sample whose error was larger than the effect — 16 rows out of 166.

How the TatuEngine v2 distiller overcame corpus, teacher, and guard challenges to achieve a stable and ready-to-use version.

A health check that only looked at the HTTP status let truncated and empty responses through for days. The probe that came after measures the body, not the envelope.

I lost 810 training steps because a 2 GB checkpoint was copied straight onto its final name and the machine rebooted mid-copy. I fixed the write on the primary volume. Two days later the same bug was living in the second-drive mirror — and it had gotten worse: the truncated file passed the resume check.

A catatonic BitMamba 1B — broken tokenizer, 10^18 gradients, a midnight ENOMEM and a CUDA wedge that faked a dead GPU — closed 500 steps and the validation reproduced the eval loss to the fourth decimal. The diary of Phase 4B on a 12 GB RTX 3060.

I resumed a run from the last checkpoint and it looked healthy — steps advancing, gradient in range, zero errors. Except the learning rate had quietly shrunk by three orders of magnitude. The cause: the LR scheduler restores more than it should when loading old state, and the fix was two lines.

The Phase 4 run dropped mid-flight with no traceback, no OOM, no error log: the process simply stopped existing. Chasing the cause turned into a lesson about watching the wrong metrics — and about the invisible cost of letting your GPU driver sweep up your garbage.

300 training steps, a loss stuck at 10.8125, and a model that insisted on coming out blank. The cause wasn't a low learning rate — it was exploded weights in the starting checkpoint. The story of how a stalled run became a full diagnosis.

The codec post ended with a dangling issue: the lm_head diverging in validation. Two weeks later, a methodical audit rescaled the model's head, generated a clean checkpoint, and became the foundation of Phase 4 — the Resurrection.

A repo that accumulates build artifacts and syncs doesn't tell the clean story you want to show. TatuEngine went through versioning hygiene: build artifacts out of git, auto-sync running, and a repository ready for outsiders to look at without handing over the internal recipe.

BitMamba-2 1B's in-engine inference representation was unworkable in memory. A compact ternary block codec delivered orders of magnitude of savings, with the lm_head diverging mid-validation.

TatuEngine had 5.7GB of AI models committed to git since day one. GitHub rejects objects above 2GB with a 422 error — that push would never succeed. The fix wasn't 'pushing through': it was an orphan branch that preserved code, tests, and docs and rewrote the repository's history from scratch.

TatuEngine got a punishment layer v3: progressive fines for repeat offenses, partial cold restart, automatic tool denial and output reprimand. The idea: instead of only rewarding good behavior, punish bad behavior with growing intensity — like an immune system that learns from every mistake.

The autopoietic agent with ToolUse, an MCP server and a hybrid sandbox is the biggest attack surface in my ecosystem. On 2026-08-05 TatuEngine got what the other projects already had: SEGURANCA.md v1.0, a 24h watchdog, and a rule that changes how the project is developed.

After learning to infer (252× GPU speedup), TatuEngine went for the Master-Apprentice cycle: a Qwen2.5-3B teacher with LoRA distilling structured reasoning ([THOUGHT]/[ANSWER]) into the BitMamba-2 1B student. Six versions in one day (v0.17→v0.22.2), 381 examples, and the convergence that wouldn't come until the system message fix.

Born from the absurd question 'what if we used RT Cores to process neural networks?', killed the dream on WSL2, and became a hybrid CPU/GPU engine with BitMamba-2 1B, radical compression, an agent with 8 subsystems and a security sandbox — 302 commits later.

When your engine runs AI-generated code, you need a sandbox that doesn't hinder development but won't let path traversal slip through.

298 commits, zero new features in 30 days, and an SSM inference engine that runs unsupervised. The TatuEngine doesn't need changes — it just works.

Exploring the current state of TatuEngine — lessons, challenges, and discoveries.

The saga of making Student BitMamba-1B learn without exploding: Adafactor vs AdamW, saving 4 GB of VRAM, and the 4 bugs that produced NaN during bf16 training.

The journey (and the craters) of training a Mamba-2 with 1.4B parameters from scratch on an RTX 3060 — warmup, SFT, catastrophic eval, and Phase 4 of the resurrection.

Exploring the beginnings of TatuEngine — lessons, challenges, and discoveries.