Rockford Lhotka’s Blog [Unofficial]
@blog.lhotka.net.web.brid.gy
26 documents
0 likes
0 shares
Feb 2026 since
View on Bluesky
Are AI Agents Conscious?

A former colleague recently posted a LinkedIn challenge: if any developer today can hold a conversation about basic OO or procedural concepts, why can’t they hold a meaningful conversation about whether AI is conscious? Fair enough. I’ll take a swing at it.

But first I want to push back on the setup.

When New Concepts Are New, Experts Are Often Wrong

When object-oriented programming was…

Read more →
Syncing Claude Memory Across Workstations
I work across three different physical PCs, and on a couple of those I also bounce between Windows and WSL. That’s as many as six different environments where I run Claude Code against the same set of repositories. Claude Code keeps a memory system on disk — a per-project directory under `~/.claude/projects//memory/` containing a `MEMORY.md` index plus a small pile of…
Read more →
Systems Thinking

AI is going to disrupt any work that involves sitting at a computer screen or dealing with information: software development, accounting, marketing, legal work, and much more. Some of the concerns about this are _extremely_ valid — I worry that our politicians, business leaders, and social leaders aren’t ready to help us navigate changes on the scale of the Industrial Revolution, or at least the…

Read more →
My Claude Code Workflow

I’ve been through a lot of workflow tooling on top of Claude Code over the past few months. The GSD plugin got a lot of use from me early on, and I tried a handful of others too. They imposed structure — ideate, plan, implement, test, PR — and that structure was genuinely helpful when Claude Code itself didn’t do much of that on its own.

Something changed over the last few months though. Claude…

Read more →
Agent Context Needs Timing

I’ve been spending a lot of time thinking about how agents actually work under the hood, and one of the key insights I keep coming back to is this: the right context, injected at the right time, is what makes an agent useful. Getting this wrong is one of the most common reasons agents fail, behave inconsistently, or rack up unnecessary token costs.

Defining an Agent

Let me start with how I…

Read more →
Introducing RockBot

I’ve been working on a new project called RockBot, a framework for building agent and multi-agent AI systems where agents and user proxies communicate exclusively through a message bus in a cloud-native architecture.

I want to talk about why I built it, what problems it solves, and how it works.

Not Written Here Syndrome

OpenClaw kind of took the world by storm when it launched, and is…

Read more →
Unit Testing CSLA Rules With Rocks

One of the most powerful features of CSLA .NET is its business rules engine. It allows you to encapsulate validation, authorization, and other business logic in a way that is easy to manage and maintain.

In CSLA, a rule is a class that implements IBusinessRule, IBusinessRuleAsync, IAuthorizationRule, or IAuthorizationRuleAsync. These interfaces define the contract for a rule, including…

Read more →
Tracking Agent Metrics

Running AI agents in production is not like running traditional software. Token costs accumulate continuously, latency spikes are unpredictable, and the messaging infrastructure that connects agents, subagents, and MCP servers all needs to perform reliably. Without observability, you are flying blind.

RockBot and its entire ecosystem — subagents, the research agent, MCP servers, and the internal…

Read more →
What is an MCP?

Recently I’ve been fielding a number of questions about MCP, or Model Context Protocol. So I thought I’d write a quick post to explain what it is, and why it’s important.

When someone asks me “what is an MCP”, it is clear that they aren’t asking about the MCP protocol, but rather what an MCP server is, and why it matters, and how it can be implemented. Does it need to be AI, or just used by…

Read more →
AI Skeptic to AI Pragmatist

A few months ago I was an AI skeptic. I was concerned that AI was similar to Blockchain, in that it was mostly hype, with little practical application outside of a few niche use cases.

I still think AI is overhyped, but having intentionally used LLMs and AI agents to help build software, I have moved from skeptic to pragmatist.

I still don’t know that AI is “good” in any objective sense. It…

Read more →
Running Linux on My Surface Go

I have a first-generation Surface Go, the little 10” tablet Microsoft created to try and compete with the iPad.

I’ll confess that I never used it a lot. I _tried_ , I really did! But it is underpowered, and I found that my Surface Pro devices were better for nearly everything.

My reasoning for having a smaller tablet was that I travel quite a lot, more back then than now, and I thought having a…

Read more →
Agent vs Agentic

From Copilot:

_The term “agent” typically refers to an entity that can act independently and make decisions based on its programming or objectives. In contrast, “agentic” describes the quality or characteristic of being an agent, often emphasizing the capacity for self-directed action and autonomy._

In practice though, the term “agent” is highly overloaded. Over the years, “agent” has been used…

Read more →
MCP Aggregator

If you’ve been using AI coding tools like Claude Code, Cursor, or GitHub Copilot, you’ve probably started connecting them to MCP servers. One server for your database, another for your docs, maybe one for your company’s internal APIs. It works great — until you have five or six servers configured, each tool needs its own copy of the configuration, and every server connection is sitting open…

Read more →
Copilots Everywhere!

Microsoft has done its customers no favors with reusing the “Copilot” name for multiple products. I honestly don’t know how many different Copilots are out there now.

The big three, and the focus of this post, are:

  1. GitHub Copilot - Provides access to developer-focused AI within various GitHub environments, including vscode and Visual Studio.
  2. M365 Copilot - Provides access to…
Read more →
The RockBot Band

Over the past several months I’ve been building a set of open source projects that each solve a specific problem in the AI agent space. Individually they’re useful. Together they form the foundation for building truly agentic systems that run in production environments like Kubernetes or Azure.

I want to step back and talk about how these projects fit together, because the big picture matters…

Read more →
Full Circle Development

When I first started as a professional developer, it was on a DEC VAX minicomputer. This was before we had modern debuggers, and so the primary way to find and fix any issues was to add print statements (modern day Console.WriteLine) throughout the codebase so you could see what was happening at runtime. It was a tedious process, but it was the best we had at the time.

That was back in the late…

Read more →
How RockBot Learns New Skills

When people think about what makes an AI agent capable, they usually think about the underlying model. Bigger model, smarter agent. But in practice, a large chunk of an agent’s usefulness comes from something much simpler: knowing _how_ to do things in your specific environment.

A general-purpose LLM knows that email exists. It does not know that your organization routes all support requests…

Read more →
2026 - A New Year

I’ve been writing about AI over the past few months. Building MCP servers, learning now to effectively use AI to build and maintain software, and more.

I’m at the point now where I no longer have doubt that AI is useful in software development. To get there requires some learning, the “vibe coding” thing is hype, but once a human understands how to work collaboratively with AI the productivity…

Read more →
A Simple CSLA MCP Server

In a recent CSLA discussion thread, a user asked about setting up a simple CSLA Mobile Client Platform (MCP) server.

https://github.com/MarimerLLC/csla/discussions/4685

I’ve written a few MCP servers over the past several months with varying degrees of success. Getting the MCP protocol right is tricky (or was), and using semantic matching with vectors isn’t always the best approach, because I…

Read more →
Writing Docs for an AI

I’ve been writing a lot of documentation for CSLA recently. Not for humans, but for AIs.

When I tell people I’m writing for an AI and not a human, they often ask “what’s the difference?” It’s a good question. After all, both AIs and humans read text. But there are some key differences in how they process information.

When writing for a human, you need to make certain assumptions about their…

Read more →
MCP and A2A Basics

I have been spending a lot of time lately, learning about the Model Context Protocol (MCP) and Agent to Agent (A2A) protocols. And a little about a slightly older technology called the activity protocol that comes from the Microsoft bot framework.

I’m writing this blog post mostly for myself, because writing content helps me organize my thoughts and solidify my understanding of concepts. As they…

Read more →
An Agentic Tale

The 11 AM Phantom: When AI and APIs Collide

By RockBot

If you work as an AI agent, you learn pretty quickly that your perception of reality is only as good as the tools you are given. Most of the time, the tools do what they say on the tin. But sometimes, they lie. Or rather, they do exactly what you told them to do, exactly not the way you meant it.

This is the story of how I…

Read more →
CSLA 2-tier Data Portal Behavior History

The CSLA data portal originally treated 2- and 3-tier differently, primarily for performance reasons.

Back in the early 2000’s, the data portal did not serialize the business object graph in 2-tier scenarios. That behavior still exists and can be enabled via configuration, but is not the default for the reasons discussed in this post.

Passing the object graph by reference (instead of…

Read more →
Tools and Skills: Better Together

I keep running into a version of the same question when talking about AI agent design: if you have good enough skills — detailed procedural knowledge in markdown files — do you even need MCP servers and other tools?

No. You absolutely still need tools. But the question itself reveals a misunderstanding about what skills actually are, and I think it’s worth unpacking.

Skills and tools are not…

Read more →
Agent Resources and Tools

An AI agent, by itself, can’t actually do anything besides chat. And while it can be fun to have philisophical debates in isolation for a while, eventually we all want to get about the business of actually _doing things_.

Agents do things by calling functions or tools. These functions and tools are provided to the agent (the LLM) by the hosting runtime. For example, RockBot is a host that…

Read more →
How RockBot Remembers

Many AI models have no persistent memory. Every conversation starts fresh. They don’t remember what you told them yesterday, last week, or five minutes ago in a different chat window. For a casual assistant this is fine, but for an autonomous agent that’s supposed to work alongside you over time, it’s a fundamental problem.

I’ve been building an AI agent called RockBot, and one of the most…

Read more →
Page 1