I’ve been asked on multiple occasions to produce a blog post covering programming with LLMs from A-Z. In this post I’ll discuss all the most important terms and definitions as well as a multitude of DOs and DONT’s with LLMs and writing code.

These statements will of course be my own opinions, however I hope you’ll be agreeing with all of them by the end 🙂 — Read More

Every AI agent you build reaches the same decision point eventually. You have a task that needs to be done — call an API, search a database, run a calculation — and you need to decide: should this be a tool the agent calls directly, or should it be a separate agent that handles the work independently?

Get this wrong in one direction and you end up with a bloated agent that tries to do too much in a single context window. Get it wrong in the other direction and you’ve added coordination overhead, extra LLM calls, and debugging complexity to a problem that a simple function would have solved.

This article explains what tools and subagents are, where each fits, and how to make the choice every time. — Read More

With ever-changing models, new and better ones coming out every few months, it’s great if we don’t have to rely on them too heavily. The better your tooling, the less dependent you become on any single model. That’s also why the deterministic harness matters: a correctness layer that lets you reproduce outputs and trace lineage regardless of which model you’re running underneath. This is especially true during maintenance or extending the project, where verification is the real job.

The danger isn’t only a crash or an error message, but a wrong number that didn’t break. It might be a clean query, but it introduces duplicated rows.

In this article, we go through the three levels of AI agents in data engineering, how to structure projects so the AI delivers its best outcomes, and how dedicated agents with a deterministic core help us build higher-quality pipelines — ones we can actually trust. And we look at a practical example of how it works with a blast radius analysis. — Read More

Context is everything in data right now. Everyone is looking for the same thing: a single place where you can ask a natural-language question and get back a reliable answer. With that, you can build conversational analytics, but you can also build essentially any agent that needs to connect to your organization’s data. As long as you have context.

… Lots of people are talking about building context layers and hiring context engineers. [nao co-founder and CEO Claire Gouze] and her team are doing it: they’ve authored a context engineering playbook with specific guidance on how to build your own context layer and how to create evals. They’ve built a community learning together in the open, and they’ve built tooling to make it easier. What I appreciated most about this conversation was its pragmatism. Rather than talking about context, we should all get to work engineering it. Claire’s playbook is a great place to start. — Read More

Long-running agents are those capable of exhibiting sustained autonomous execution over time. In these agent-based applications — fueled by interactions with users or other systems in which information snowballs rapidly — the context window is a critical bottleneck. Agents and large language models, or LLMs in their abbreviated form, are two sides of the same coin in modern AI systems, so to speak. Accordingly, shifting from “LLMs as prompt-response engines” to “(agent-endowed) LLMs as long-running background processes” turns context windows into a major AI engineering bottleneck.

For all these reasons, managing context windows in the long run requires specific strategies like sliding windows, tiered memory, and dynamic summarization. This article presents five different operational strategies for this, together with their inevitable tradeoffs. — Read More

Write like Python, run like C++. Write fast code for diverse hardware, from CPUs to GPUs, without vendor lock-in, in a language that’s both user friendly and memory safe.

Mojo draws inspiration from the best parts of modern languages – like Python’s intuitive syntax, Rust’s memory safety, and Zig’s powerful and intuitive compile-time metaprogramming. It is built from the ground up to deliver the best performance on the diverse hardware that powers modern AI systems. As a compiled, statically-typed language, it’s also ideal for agentic programming.

… The Mojo standard library is fully open-source on GitHub and we welcome contributions! We also plan to open-source the Mojo compiler in 2026. — Read More

Workday, the payroll and HR data platform, has been pursuing AI and agents for a while, but while other businesses may allow a little room for error, getting a payroll run in Workday 99% right is not exactly good enough.

… “There aren’t many systems that are more critical — or less forgiving — than ones that are dealing with people and money,” he says. There’s no tolerance for “well, it works most of the time,” Gabe Monroy, Workday’s CTO, says in an interview. — Read More

Over the last months I have watched more and more people build something on top of coding agents that feels meaningfully different from just using a coding agent. Some of this happens on top of Pi which is cool to see for sure! The pattern is the same everywhere though: work is put into a queue of sorts, a machine picks it up, attempts it, stops, and then some harness decides whether that was actually the end.

If not, the harness continues the same session, injects another message, starts a fresh session with modified context, or sends the task to another machine. The task stays alive beyond the point where the model by itself would normally have said: “I am done.”

… There is already an agent loop inside every coding agent. The model calls a tool, incorporates the result, calls another tool, reads a file, edits a file, runs tests, and eventually produces some answer. That loop is one we have been quite familiar with for a long time. The other loop is the harness level loop: the loop outside the agent loop. That loop is also not new. We have been doing versions of this since early Claude Code days, but that loop is becoming ever more present in agentic engineering and in recent weeks it has started to dominate the Twitter discourse. — Read More

In this blog post, I will share the adventures I had creating my own LLM, from (almost) scratch, trained only on old texts.
I made my own base-training and fine-tuning scripts, data processing pipelines and custom datasets.
(“almost from scratch” means I did use existing programming languages and libraries, I didn’t write in Assembly, just like anyone else who builds an AI “from scratch”…)

The model can be found on HuggingFace: https://huggingface.co/croqaz/vintage-LLM-340m-v1-base ; All the code is open source at: https://github.com/croqaz/vintage-LLM ;

If you want to check bigger Vintage models, see my previous post: Vintage LLM models. — Read More

Anthropic recently had to pull Mythos/Fable due to an edict from the US government. While Mythos was a step up from Opus, I’ve been actively moving smaller in terms of my agentic models—and matching the quality of output of some of the largest frontier models.

The use cases have spanned from hard “hedge fund level” (for want of a better description) market analysis, financial management, and AI personal assistants to even helping a few friends in difficult medical situations. I’ve called this pattern “knowledge agents” with a generic template available to everyone here. They literally inject the right knowledge into the AI agent plugged into it. Anyone can do this, with or without my template. — Read More