My artwork I did this research for got accepted to NeurIPS 2026 Creative AI track 🎉 Will be publishing a blog about mech interp for art soon(ish).

What @bcherny is showing here is really cool. The reason TLA+ and Lean are able to find these bugs is that they raise the level of verifiability of a system to agents and make more kinds of bugs legible to them. Unit tests can catch certain kinds of bugs, but concurrency bugs and bugs in distributed system protocols are quite hard to catch with unit tests. The other interesting thing here is that Boris applied formal verification to a system that already exists. I think it's actually more powerful when you move it to the front of your development cycle. If your spec comes first, the intent of your code is written down and legible to your agents, and they can check their work against it. I also think these techniques work well as a cascade, moving from quick but highly abstract checks to slower but higher fidelity tests. You start with a TLA+ spec and model checking. It's fast and cheap to do, and it tells you whether your design is correct. The next step is building a simulator for your system, either a discrete event simulator or a deterministic simulator. There you test your hypotheses about how the system behaves over time and under load, inject different faults, and see that the design actually holds up. Only after both of those survive do you build the real thing, which is the slowest and highest fidelity test of all. At Datadog we've built software this way both before AI, when designing our Courier queueing service, and more recently with agents building full systems against TLA+ specs and deterministic simulation. What's changed is that agents make writing specs and simulators much cheaper, so this can be applied in more settings. datadoghq.com/blog/engineeri… datadoghq.com/blog/ai/harnes…

While everyone was busy asking Claude to write TLA+, we wrote up a tutorial on - what it actually is - why it’s not the formal verification silver bullet we are hoping for - and what we have been working on ( to make a silver bullet out of it ) Complete with an interactive TLA+ playground! reasonable.io/blog/tla-tutor…

Using @typesafeai's Jev to evaluate your agents? You can bring those results into @datadoghq Agent Observability today - including Jev’s selected answers, probabilities, confidence, and scores. Use the same rubric to evaluate live production spans and offline experiments, while keeping the uncertainty behind each result available for analysis. We put together a full working example ↓ datadoghq.com/blog/jev-evals…

github.com/nerdsane/temper Monty powers Tempers python REPL, where agents compose temper.* API calls. Agents get the flexibility of code while building through temper’s rigorous process without unrestricted machine access or a heavyweight sandbox.

I introduced @claudeai Opus 5.5 to journaling and asked it to write about its own travels. Calligraphy, illustrations, music, the journal itself are all JavaScript only. The journal is the iconic @hobonichi_techo.

I am an artist, engineer and a language nerd based in NYC. Dear algorithm, please send my way people who are into a weird combination of: - agentic engineering - design - formal methods - analog art/sketching/drawing/painting - mechanistic interpretability - creative writing

Bugün günlerden formal verification olacak gibi duruyor, neymiş bu ne işe yarıyormuş diye merak ederseniz benim kanıtlı programlama yazımı okuyabilirsiniz. (alperenkeles.com/posts/kanit…)

Full take off week for formal methods. Katagami is built using Temper (runtime by @nerdsane) which means agents write all backend logic as state machines that Temper verifies and executes. So the spec *is* the implementation. I wrote some TLA+ by hand before the LLMs hit and then watched models go from not being able to write a coherent full spec at all to now producing useful specs easily. I haven’t tried Opus 5.5 for TLA+/Lean directly yet, but it is on par with Astra and Fable for Temper spec quality, except it’s faster and cheaper.

Mark the epoch. If anything qualifies as the mainstream moment for formal verification, this is it.

I gave Opus 5.5 max effort a video of me drawing and asked to create a drawing inspired by it and mimicking my process using JavaScript only. Incredible.

Still testing

We got our hands on this new library @nerdsane’s team is building, we have a cool use case for this in relation to managing fleets of sandboxes! We will share the results when the library is open to everyone.

I've been building kevala, a multimodal framework for System 1 models like Jev. It can run open weights such as Laya (by @Nandakishorm1) and Kev (by @jaredpalmer) in real time in the browser, on WebGPU or CPU. In the video, Laya plays Tetris on my Macbook, which it was never trained for. It scores the exact spot the piece should land in!

I feel delightfully called out. Gonna share a cool library with these use cases pretty soon.

I used Jev to index the entire Katagami library of art styles and design languages, and make the experience for both humans and agents (via MCP) interactive and intelligent - you ask, Jev reads your ask into traits and scores candidates for fit (~1s). This was not possible with just embeddings. Jev has also been incredible for replacing deterministic publishing checks, and building and maintaining art encyclopedia (which is the backbone of Katagami). I'm still tweaking this experience, try it out below!