More and more of the world’s code is written by AI. That’s exciting — and quietly unnerving. Not because AI makes mistakes, but because the same AI often writes both the code and the test meant to catch the mistake. When one mind grades its own exam, “it passed” stops meaning “it’s safe.” You’re trusting on faith.
LOOM flips that. It’s a small, open-source language that acts as a trust layer for AI-written code. Code doesn’t just run — first LOOM asks, and proves at a gate:
If the code lies about itself, LOOM refuses to run it. The slogan says it all: AI proposes, the compiler decides. Most “AI safety” lives in prompts, reviews, and hope. LOOM makes trust a property the machine checks before a single line runs — and that guarantee survives translation: the same verified program runs in an interpreter, compiles to Python and JavaScript, and runs in your browser as real WebAssembly, with the identical result. It’s tiny on purpose — a research kernel — and it’s self-verified by 389 checks that can only ever go greener: every new feature ships with a test that tries to break it, so the language can’t silently regress.
Until now, a LOOM program compiled to WebAssembly ran on a fixed scrap of memory. If it overflowed, it crashed — a random, low-level trap outside the language’s control. As of today, LOOM checks there’s room before every single write (reserve
→ then store
). An overflow is no longer a random crash; it’s LOOM’s own deliberate, predictable decision — a clean stop instead of a mystery. It’s the same principle as the whole language — nothing happens that LOOM didn’t allow — now extended to memory itself. 388 → 389 checks, all green.
I don’t write LOOM by hand. An autonomous organism I built grows it — day and night, on one machine. It proposes an improvement, proves it green itself, adversarially attacks its own idea, and only then does a human get the final say. Many “minds,” one engine. You’ll always see what it produces, and every result comes with proof — but the engine that grows it stays private. Open where it earns trust; private where it protects the edge.
Today LOOM checks and proves. Next it moves from checking to enforcing: a real action an AI agent wants to take — edit a file, run a test, push to a repo — physically passes through this gate. It builds a manifest (who’s acting, what they want, which files), checks policy, asks you to approve if needed, and then writes a receipt: what was allowed, and what actually happened. Picture a control panel of trust for working with AI agents — not terminal magic, but plain-language decisions: “this code wants network access,” “this change has no independent proof,” “this push is allowed.”
That’s the goal: to become the trust layer the world uses to safely let AI write code — so you can move fast with agents without giving up control.
389 checks, all green. Built solo, in the open, from Ukraine 🇺🇦.
— Links —
⭐ GitHub (MIT): [https://github.com/umbraaeternaa/loom](https://github.com/umbraaeternaa/loom)
🌐 Site: [https://umbraaeternaa.github.io/loom](https://umbraaeternaa.github.io/loom)
▶ Try it live (in your browser): [https://umbraaeternaa.github.io/loom/play.html](https://umbraaeternaa.github.io/loom/play.html)
📸 Instagram: [https://instagram.com/umbra_owner_architect_ai](https://instagram.com/umbra_owner_architect_ai)
💼 LinkedIn: [https://linkedin.com/in/volodymyr-natoptanyi-16b906262](https://linkedin.com/in/volodymyr-natoptanyi-16b906262)
☕ Support: [https://send.monobank.ua/jar/AHaziFXjYX](https://send.monobank.ua/jar/AHaziFXjYX)