Seven months ago, I sat down to write a blog post about a feeling I couldn’t shake. Something fundamental was shifting in how we build software, and I wanted to understand it. I’d spent my career watching these transitions unfold, from the early internet to cloud computing to mobile, and I recognized the signs. The ground was moving again. So I did what I always do when I’m trying to understand something: I started writing.

That first post, Exploring the Age of AI Agents, was ambitious to the point of recklessness. I sketched out a twelve-part series covering everything from the anatomy of an agent to the ethics of autonomous systems. I had an outline, a rough timeline, and the kind of optimism that comes from not yet knowing how hard the thing you’re attempting actually is. “The age of agents is here,” I wrote. “Let’s explore it together.”

I meant it. But I had no idea what I was signing up for.

What I Thought I Was Writing

When I outlined the series in September 2025, I thought I was writing a technical guide. A structured walkthrough of how agents work, piece by piece: how they think, how they remember, how they use tools, and so on. I imagined the series as a kind of textbook, assembled in public, one chapter at a time.

That’s not what it became.

The series became a journal of a landscape in motion. Every time I sat down to write the next installment, the ground had shifted since the last one. I wrote about agent frameworks in November, and by January the framework landscape had already reorganized itself around protocols I hadn’t anticipated. I wrote about guardrails as a theoretical necessity, and then watched OpenClaw demonstrate exactly the kind of third-party skill exploitation I’d warned about, at a scale that made the warning feel inadequate. I outlined “When Agents Talk to Each Other” as Part 9, imagining it as a speculative look at a future problem. By the time I wrote it, MCP had become the most discussed protocol in the developer ecosystem, A2A had launched, and the “future problem” was a present reality.

The pace of change didn’t just affect the content. It changed how I build software. In September 2025, I was writing agents by hand, stitching together ReAct loops in Python scripts with explicit tool-calling logic. By January 2026, I was watching my own projects inevitably evolve into agents whether I planned for it or not. By March, I was writing a post arguing that the CLI-vs-MCP debate misses the point entirely, because I’d lived through the transition from “agents are a design pattern” to “agents are the default architecture” in real time.

What Surprised Me

Three things caught me off guard.

The first was how quickly “agentic” stopped being a buzzword and became a description of how software actually gets built. When I started this series, calling something an “agent” still felt like a stretch, a term borrowed from research papers and applied generously by marketing teams. By the time I finished, every major development tool I use daily had adopted the agentic loop as its core interaction model. Gemini CLI, Claude Code, GitHub Copilot Workspace: they all run models in loops with access to tools. That’s not hype. That’s the new baseline.

The second surprise was how much the human side of this story matters. I started the series focused on architecture and implementation. I ended it writing about a student who decided not to study computer science because AI made it seem like it wasn’t really a job anymore. I ended it writing about Klarna replacing 700 people and then quietly rehiring because pure automation couldn’t replicate empathy. The technical architecture matters enormously, but the posts that generated the most conversation, the most email, the most “I’ve been thinking about this too,” were the ones that grappled with what agents mean for the people who build and use and are affected by them.

The third surprise was personal. Writing this series made me a better engineer. Not because I learned new frameworks (though I did), but because the discipline of explaining something forces you to understand it at a depth that using it never requires. I couldn’t write about the observability gap without building observability into my own systems. I couldn’t write about meaningful human control without rethinking the autonomy boundaries in my own agents. The series was supposed to be me sharing what I knew. It turned out to be me learning in public.

The Map and the Territory

Looking back at the original table of contents, I’m struck by how well the structure held up and how differently the substance landed than I expected.

The early posts, Parts 1 through 4, were the foundation: anatomy, reasoning, memory, tools. These were the most “textbook” installments, and they still hold up as reference material. If you’re new to agents, start there. The core concepts haven’t changed, even as the implementations have matured dramatically.

The middle posts, Parts 5 through 8, were about the craft of building agents well: guiding behavior, putting up guardrails, managing attention, choosing frameworks. These turned out to be the posts I return to most in my own work. The technical patterns here, prompt engineering as programming, context window management as a first-class concern, guardrails as architecture rather than afterthought, are the ideas that separate a weekend prototype from a system you’d trust with real work.

The later posts, Parts 9 through 12, were where the series found its heart. When Agents Talk to Each Other captured the moment the ecosystem shifted from building isolated agents to building the connective tissue between them. The Observability Gap articulated the wall every builder hits when moving from demo to production. Agents in the Wild made the theory concrete with real deployments at real companies. And Responsibility and the Road Ahead confronted the question that my self-deleting agent made impossible to avoid: capability without responsibility is just risk with extra steps.

Where the Road Goes

I’m not done writing about agents. The territory is too large and too fast-moving for any single series to cover completely. But I’m shifting focus.

The Agentic Shift was about mapping the fundamentals: what agents are, how they work, and what it takes to build them responsibly. The next chapter, for me, is about what happens when these fundamentals leave the terminal and enter the rest of life. When agents aren’t novel but expected. When the question isn’t “should we use agents?” but “how do we live and work alongside them?”

Back in April 2025, before this series even started, I wrote about waiting for a true AI coding partner. I was describing something I could feel but couldn’t quite build yet: an AI that didn’t just generate code on command but genuinely collaborated, anticipated needs, and earned trust through consistent, reliable behavior. That vision hasn’t changed, but it’s expanded. I want to build agents we can trust as collaborators, not just in code but in the fabric of daily life.

I’m thinking about home and family. Calendars that don’t just display events but reason about conflicts, coordinate across family members, and suggest adjustments before anyone has to ask. Financial tools that don’t just track spending but understand patterns, flag anomalies, and help a household make better decisions over time. An always-on system that manages the house itself, making reasonable decisions about lighting, climate, energy usage, and routine maintenance without requiring a human to micromanage every automation rule. Not a smart home in the current sense, where everything is a manual trigger dressed up as intelligence, but something closer to a thoughtful presence that understands how a family actually lives and adapts accordingly.

These aren’t science fiction problems anymore. The architecture we explored in this series, perception, reasoning, memory, tools, guardrails, is exactly the stack these systems need. The hard part isn’t the technology. It’s the trust. And that brings me back to the theme that ran through every post in this series: autonomy should match consequence, and the humans should always be able to take the wheel.

I’m also watching the broader landscape. The protocol wars are far from settled; MCP has momentum, but A2A and ACP are finding their niches, and the “bridge pattern” I described in my MCP post is becoming the pragmatic default for tool developers. The economics of agentic software are reshaping the SaaS industry in ways that are still unfolding. And the workforce implications, the thing that keeps me up at night more than any technical challenge, are only beginning to be felt.

I also want to go deeper on building. The Agentic Shift stayed mostly at the conceptual and architectural level, but my own hands-on work kept pace with the writing. Much of that happened in and around Gemini CLI, which became my primary development environment and a testing ground for the ideas in this series. I built a policy engine for Gemini CLI while writing Part 6 on guardrails, and the two fed each other in real time, the code revealing gaps in the theory and the writing sharpening the implementation. I wrote extensions for Google Workspace that gave agents access to real productivity tools. I integrated deep research workflows into my terminal. Gemini Scribe continues to evolve alongside all of it. My podcast RAG system keeps teaching me things about retrieval and memory that I didn’t expect. There are new tools to build, new patterns to discover, and new failure modes to document.

The Bookend

I want to end where I started. In September 2025, I wrote that we were standing on the cusp of a fundamental shift. I listed the transitions I’d witnessed in my career: the internet, the PC, cloud computing, mobile, social media. And I said this one was next.

Seven months later, I don’t think we’re on the cusp anymore. We’re in it. The shift happened while I was writing about it. Agents moved from research papers to production systems to the default way software gets built, and they did it faster than any of the previous transitions I compared them to. The twelve posts in this series captured one slice of that movement, one engineer’s attempt to make sense of a landscape that refused to hold still.

I’m grateful to everyone who followed along. The emails, the comments, the conversations at meetups and conferences where someone would say “I read your post about guardrails and it changed how we’re building our system.” That’s why I write. Not to have the definitive answer, but to think out loud in a way that helps other people think too.

The age of agents is here. We explored it together. And the exploring isn’t over.

Let’s keep building.