What Chasing Agent Harnesses Taught Me About Building in the Wild West of AI

Over the past year, I moved through a long list of agent harnesses. Cursor-CLI. OpenCode. OpenClaw. Codex. Hermes. Pi. From the outside, that can look scattered.

It wasn't.

What I was really doing was research and development in a space that still does not have stable rules.

That matters because the current agent ecosystem still feels like the wild west. Standards exist, but they change quickly. Best practices exist, but many of them are really just the current shape of the tooling. If you only follow the accepted path, you can move quickly, but you can also inherit limits you do not fully understand.

I took the slower path.

I am self-taught, and that has turned out to be an advantage here. I did not come into this space overly attached to the standard abstractions. I was willing to read the research, build my own systems, break them, migrate them, and keep going until I understood where the real constraints were.

Before I spent serious time in harnesses, I was already building memory systems with Neo4j, PostgreSQL, and vector search. I was also building MCP servers and trying to solve orchestration. Not just tool use. Orchestration. How work gets decomposed. How dependencies are tracked. How a system keeps going when the task is bigger than one prompt and one answer.

That led me to build Askesis, my own orchestration layer. What it taught me was simple: deep research and long-running agent work are mostly the same problem. Both require decomposition, branching, persistence, and synthesis. That insight ended up shaping how I looked at every harness after that.

Each harness taught me something different.

Cursor-CLI showed me how quickly a read-heavy memory system can become expensive. OpenCode gave me a better home for multi-agent thinking. Codex showed me the value of a cleaner opinionated environment, even if it was not the right fit for what I was building. Hermes helped me compare my own systems against the market more honestly. Pi matters to me now because it feels like a substrate I can shape instead of a product I have to stay inside.

What kept me moving was not indecision. It was mismatch.

I was trying to build systems with continuity. Agents with memory that survived sessions. Coordination that felt more like a real room and less like a race condition. An intent layer that treated Telegram, schedules, and internal triggers as different sources for the same kind of event. A framework for evaluating whether an agent had actually learned from experience instead of just sounding confident.

Those were not standard product concerns. They were R&D concerns.

And that is why I think this work translates well to employers.

We are still early enough in agent systems that a lot of valuable work looks messy while it is happening. The person who can only operate inside mature tooling will be limited by the maturity of the tooling. The person who is willing to read, test, prototype, and rebuild can often get to the needed functionality sooner.

That is the skill I have really been developing.

Not loyalty to one harness. Not surface-level familiarity with the tool of the month. The ability to work through ambiguity, understand the underlying system, and do what is needed to get the functionality that matters.

I do not think that matters less as the technology advances. I think it matters more.

As the agent ecosystem matures, there will be more polished tools and better defaults. That is good. But there will still be gaps between what the tools are designed to do and what real teams need them to do. Someone still has to bridge that gap.

That is the kind of work I have been doing.

So when I look back at all the harness switching, I do not see wasted motion. I see a record of learning. I see someone working through an unstable field by building, testing, and adapting in real time.

That is what I have to show for it.