Useful Agents Are Harder Than They Look

I had a content plan in March.

It was a pretty good one, I thought. The strategy made sense. I knew what I wanted to write about. I had a few existing blog post ideas I could use. I had themes for LinkedIn, Facebook, groksrc.com, and StartWithDrew. The whole thing connected back to what I was actually building: Basic Memory, AI systems, small business tools, and the strange new reality of trying to do more with a much smaller team.

Then I stopped posting.

That is the annoying part. The plan did not fall apart because I ran out of ideas. It fell apart because the machinery underneath it wasn’t reliable.

The part I wanted to automate

The idea was simple enough.

I wanted an agent to help me keep the content engine moving. Find good LinkedIn posts to respond to. Watch the people I care about in my network. Draft replies in my voice. Pull ideas from Basic Memory. Turn those ideas into posts. Keep a queue moving so I did not have to start from a blank page every time.

That is exactly the kind of work AI should be good at.

A lot of content work is not creative genius. It is remembering what you already said. Pulling the right note at the right time. Turning one idea into a few formats. Noticing that a conversation from Tuesday would make a good post on Thursday. Keeping the thread alive.

So I tried to build a system around that.

The system depended on OpenClaw. OpenClaw was ambitious. It ran as an agent on my machine, connected to my tools, and was supposed to handle background tasks while I was doing other things. That was the shape I wanted. I did not want another app sitting there waiting for me to click buttons. I wanted an assistant that could notice, prepare, and remind.

In practice, it fell apart.

Some days it worked. Other days the config drifted. Browser automation broke. A plugin behaved differently than I expected. Model access changed underneath it. A job did not run, or ran in a way I did not understand until I went digging through logs later.

That is a bad place for a content system to live.

Content is already hard enough to do consistently. If the thing that is supposed to reduce friction creates more uncertainty, you stop trusting it. Once you stop trusting it, you stop checking it. Then the whole loop dies quietly.

That is what happened.

The real agent problem

People talk about agents as if the hard part is getting the right output.

Can the model reason? Can it use tools? Can it browse the web? Can it write a good draft? Can it call an API?

Those things matter. They are also the demo parts.

A useful agent has to be boring in ways demos do not show.

It has to remember state. It has to recover from partial failure. It has to know when a browser session is stale. It has to avoid doing the same work twice. It has to leave a trail I can inspect later. It has to run at the right time. It has to fail loudly enough that I notice. It has to handle permissions, credentials, file ownership, working directories, rate limits, weird local machine stuff, and all the other junk that lives outside the prompt.

That is where most of the work is.

The model can write a decent LinkedIn reply in a few seconds. The bigger problem is getting the loop to run every weekday, find the right posts, avoid duplicates, draft in my voice, ask for approval, post only when approved, remember feedback, and avoid randomly breaking because Chrome got weird.

That is production AI. The plumbing. The part nobody screenshots.

I keep relearning this lesson because I keep wanting the future to arrive faster than the support structure around it.

The embarrassing part

The failure was directly related to the thing I was trying to write about.

One of my main content themes this year is that AI changes what small teams and individual builders can do. I still believe that. More than ever.

But the failure mode matters too.

AI lets you move faster. It does not remove the need for a system.

If anything, it makes the system more important, because now you can create more loose ends than before. More drafts. More automations. More half-finished ideas. More background jobs. More repos with one clever script that worked exactly once.

That is where I got myself into trouble.

I had a content strategy. I had source material. I had tools. I had agents. What I did not have was a small, reliable operating loop that I trusted enough to use every week.

So I am rebuilding from there.

The reset

This week I am starting smaller.

No big autonomous content machine. No elaborate LinkedIn scanner as the first dependency. No background agent that has to work perfectly before I can publish.

The loop is going to be simple:

1. Keep a short queue.
2. Draft from things I actually did or learned.
3. Review before publishing.
4. Post manually if needed.
5. Capture what happened.
6. Repeat next week.

That is less exciting than a fully autonomous agent. It is also much more likely to survive contact with Monday morning.

The automation can come back later. I still want it. I still think it is the right direction. But it has to earn its way back into the loop by making the system more dependable, not more fragile.

For now, the agent helps me prepare. I still own the publish button.

That feels like the right balance.

What stuck with me

I do not think OpenClaw was a waste of time. It taught me a lot. Some of those lessons are showing up in the way I use Hermes now. Some of them are showing up in how I think about Basic Memory. Some are just scars from running too many background jobs on a Mac and pretending that was an operating model.

Useful agents are systems. And systems need boring things.

Logs. Queues. State. Recovery. Review. Clear ownership. A way to tell when the thing did not happen.

Without that, the agent is just another source of anxiety. It might do the work. It might not. You will find out later, probably at the worst possible time.

I want something better than that.

So this is me restarting the content loop, but it is also me being honest about where the last attempt broke.

The strategy was fine.

The trust layer was missing.

That is the part I am building now.

I’m Drew Cain. I build AI tools from Austin, TX. I’m the co-founder of Basic Memory, and I spend a lot of time thinking about what it takes for AI systems to be useful outside of demos. If this resonated, you can find me on LinkedIn, GitHub, or Mastodon.