Hi all. I have spent about five years building realtime AI assistants, first in the financial domain and later as a platform, and the version I would build today looks nothing like my first one. Four things I would do differently, all of them learned the slow way. Make the flow something you can look at. My early systems were an intent classifier feeding nested conditionals. It worked, and it was miserable, because the flow existed in the code, in my head, and in a diagram that went stale in a week. Every change came through me, onboarding anyone took a month, and nobody else could say with confidence what the system would do with a given message. Being able to point at the flow changed the work more than any model upgrade did. Treat human sign-off as a starting assumption, not a later feature. I tried to add it afterwards once, and it fought everything, because the system had been built on the idea that a run starts and finishes. If you assume from the beginning that a run can wait for a person, it costs you almost nothing. If you assume it cannot, you end up building a second system alongside the first. Do not let the choice of model spread through your code. Mine was mentioned in enough places that swapping provider was a week of edits, and a cheap step ended up quietly running on the expensive model for a while before the bill said so. Deciding once, in one place, what each step is for and which model serves that is a small bit of discipline that keeps paying. Decide what happens when the model is wrong before you ship, not after. It will be wrong. The question is only whether the system around it was designed for that or is finding out in production, and I have done it both ways. None of this is exotic, and all of it is the difference between a demo and something you can hand to a team. I have put a full working reference for it in public, with a series writing up each decision including the ones I got wrong first. Who might get something from it: Maintaining something that has become hard to change: the story of how it got that way is the first thing I wrote. Still at the whiteboard: these are the calls that are cheap now and costly in a year. Turning "I have called an LLM API" into something hireable: this is the shape those listings are describing. Shipping for clients: a structure you can adapt and still leave behind maintainable. The project and the series are in a comment below. It runs on a scripted model as well as a real provider, so the whole flow is watchable before you wire anything up. Only two parts are published with more every couple of days, so feedback now still shapes the rest 😄
This article breaks down six design paths for the 2026 Agent framework (LangGraph, OpenAI Agents SDK, CrewAI, Dify, vendor-native SDK, Pi) and provides selection recommendations based on dimensions such as state management, process complexity, human-machine interaction, and model flexibility. It is suitable for teams looking to choose an Agent framework in a production environment.
An experienced practitioner shares hard-won lessons from deploying 25+ AI agents to production, arguing that memory, orchestration, and auditability matter far more than model choice. The article details common failure modes like context loss and silent cost loops, and recommends a stack including Claude Sonnet 4, Pydantic AI, and dedicated memory layers like Octopodas.
The article discusses strategies for engineering AI agent skills at scale, including context minimization, lazy-loading, executable operations, and outcome-based measurement.