Search for a command to run...
I publish articles about my AI/ML experiences and learning journey as an AI Engineering Practitioner. Tips + Tricks + Riffs devoted to taking AI/ML applications from prototype to production.
In this series of articles, I'll be presenting different implementations of AI Agents, along with other articles, over the next many months. Subscribe, keep an eye out and please let me know what you think!
Learning the Why Behind the How My previous article talks to AI Agents going mainstream in 2025. Part of this series is explaining the Why Behind the How. As you progress through your AI/ML learning journey, you will need to maintain some level of un...
Learning the Why Behind the How My previous article talks to AI Agents going mainstream in 2025. Part of this series is explaining the Why Behind the How. As you progress through your AI/ML learning journey, you will need to maintain some level of un...
AITX AI Hackathon Recap Hello and hope you’re doing well. The AITX AI Hackathon last weekend was an amazing event bringing together over 50 devs, aspiring ML Engineers, and enthusiasts with Austin AI Tinkerers for a full day of hacking and collaborat...
It has been some time since I’ve dropped digital ink to canvas. I’ve been very busy over the last year diving deeper into Artificial Intelligence (AI) and Machine Learning (ML). This short update is to let you know about the AI Community Hackathon in...
How have you been doing?! 🤔🤗 It’s been awhile since I’ve posted so I figured February 29, 2024…Leap Year Day (or is it Leap Day of the Leap Year??) is a good time to reboot. I’ve taken a few months off from writing so as to mainly focus on learning...
Build It => Deploy 🚀
18 posts
Tips + Tricks + Riffs devoted to my experiences building modern AI products and applications. See my professional site to contact me.
AI Agents are really going mainstream in 2025, where 2023 was about chatbots and 2024 was about RAG.
The most interesting thing about AI Agents in 2025 isn't what they can do - it's how they're doing it. I've been digging into the technical architecture of modern AI Agents, and there are some fascinating patterns emerging that deserve more attention.
First, let's clarify what we mean by AI Agents. These aren't just LLMs responding to prompts anymore. Modern agents are stateful systems that maintain context across interactions, manage their own memory, and make autonomous decisions within defined boundaries. The key breakthrough has been in what I'm calling coherent persistence - the ability to maintain consistent behavior patterns across extended interactions.
Here's what's actually running under the hood of a typical modern agent:
class ModernAIAgent:
def __init__(self):
self.working_memory = CircularBuffer(max_size=1000)
self.long_term_memory = VectorStore()
self.action_space = ConstrainedActionSpace()
self.context_manager = HierarchicalContext()
The interesting part is the HierarchicalContext. Unlike earlier agents that treated each interaction as a flat sequence, modern agents maintain multiple layers of context simultaneously. They're basically running a distributed state machine where different aspects of their behavior can evolve independently, where they are able to offload synchronous and asynchronous actions through AI tools or functions.
The real power comes from how these agents interact. I've been experimenting with networks of specialized agents, each handling different aspects of complex tasks. The breakthrough isn't in individual agent capabilities - it's in the protocols they use to coordinate.
Here's a typical agentic interaction flow:
The key insight: agents don't need to be general-purpose. They're most effective when they're specialized and coordinated through well-defined protocols. Different AI Agent frameworks vary in their implementation of the above diagram, and the results of their agents and predefined workflows may vary.
One pattern I'm particularly excited about is using SQLite as a persistent memory store for AI agents. It's lightweight, reliable, and - most importantly - human-readable. Here's a schema I've been using:
CREATE TABLE agent_memory (
timestamp TEXT,
context_hash TEXT,
memory_type TEXT,
embedding BLOB,
content TEXT,
metadata JSON
);
This makes agent behavior debuggable and allows for interesting queries across their memory space. Want to know how an agent's decision patterns have evolved? Just query the database! Of course, SQLite is not the only option for persistent memory storage. Based on your path from experimenting to prototype to production you may make other Agentic architectural design decisions.
Observable PatternThe most successful agent implementations I've seen follow what I'm calling the observable pattern - every action and decision is logged, queryable, and traceable. This isn't just about debugging; it's about understanding how agents actually operate in production. Imagine having 100s if not 1000s of agents in production; you will need a way to measure their performance and determine their predicability. That’s where evals are critical.
Below, is a simplified class for implementing agent decision trees:
@dataclass
class AgentDecision:
timestamp: datetime
context: dict
options_considered: list
chosen_action: str
confidence: float
The most exciting developments aren't in making agents more powerful - they're in making them more predictable and maintainable. We're seeing the emergence of design patterns that make AI agents behave more like traditional software systems: testable, debuggable, and maintainable.
The future isn't in building bigger models or more complex architectures. It's in developing better patterns for composing and coordinating specialized agents. Think microservices, but for AI.
I’ll be publishing a series of articles presenting different implementations of AI Agents, along with other articles, over the next many months. Subscribe, keep an eye out and please let me know what you think!