From Chatbots to a Fleet of Agents: My AI Journey

I am on Version 5 of my personal AI setup and Version 6 is already being built. If that sounds unstable, it isn't. Building for flexibility, in my opinion, is a wise step.

Here is the honest version of how I got from asking random facts and simple research to a coordinated fleet of agents running pieces of my business.

Versions 1 and 2: Templates, Then the First Real Unlock

I started in late 2024 where most people start. Simple questions to Gemini and Perplexity, the occasional ChatGPT sanity check, then the next natural step. I had a model compile a stack of spreadsheets and source documents into a deliverable template. That alone felt like magic at the time, and it hooked me on what was possible with workspace features like Claude Cowork.

The real unlock, though, came from code. I had an older application I was paying a third-party shop to extend. I picked up a Cursor subscription in February 2026, because it was the only tool at the time that handled multi-repo projects comprehensively. Making changes there taught me what "agentic coding" actually means, and it reframed my sense of the ceiling.

Then I learned you could point Cursor and Claude Code at non-coding tasks too. I was hesitant, because on the surface it felt like using a scalpel to open mail. After trying it, the power and flexibility were obvious. One oddity stuck with me, and still does. Claude Code could do dramatically more than Cowork, through the same vendor's desktop app. The lesson is one I still apply. The version of a tool you meet first is rarely the most capable one.

Three Things That Have Never Changed

Around this point, three constraints hardened for me, and they have driven every version since:

• Model and platform flexibility, because no single vendor stays ahead for long.
• Controlled costs, because agent token burn is real money, and it scales with ambition.
• Access to my agents while travelling, because I am not in one chair.

If a design choice compromises one of those three, it goes back on the shelf. That rule has saved me more than I can count.

Version 2: Owning My Own Agent Memory

I gave OpenClaw a try. I quickly bailed, because I was spending all my time keeping it alive rather than doing work. I was not discouraged, I was informed. I ordered a Mac mini and started building my first "agent-brain."

Gemini Gems and Claude or ChatGPT projects showed me the shape of how agent memory works, but something about bolting that onto Claude Code felt wrong. The memory needed to be mine. Relevant to my business, my clients, my household, my prior decisions. Not a vendor's copy that drifts whenever they rev a product or change a pricing tier.

I stumbled onto Andrej Karpathy's framing of an LLM as a new kind of operating system, where the model is the kernel and context, memory, and tools orbit it. I built a variation on that idea. I ran it locally on Ollama, first with Qwen, which produced distilled memories that were dramatic and missing key facts. I then switched to a Gemma release that behaved much better. My Mac's memory limits bit me hard, and I spent real time with Claude Code tuning the whole pipeline. That tuning is where "I bought a Mac" became "I understand how my stack actually breathes."

It was at the end of this stage that I realized that agents were nothing more than code with an LLM plugged in where needed. Marinate on that for a moment.

Version 3: Roles, Schedules, and a Dashboard

With a working agent-brain in place, Version 3 was an opinionated step up. I built what I call an agentic operating system. Many agents, each with a written role description, some running on their own schedules, and a dashboard showing system health and the queue of work.

That dashboard matters more than it sounds. If you cannot see what your agents are doing, you are not operating a system, you are hoping. A role description without transparency is just a vibe. Anyone who has ever managed a human team already knows this, and it turns out agents respond to exactly the same discipline.

At the same time I started building JungleOS, a consulting-operations suite you can read about at Jungle-OS.com. The product work exposed a messy pattern. I was manually carrying ideation and product decisions from Claude conversations over to Cursor to execute. I was being the integration layer, which is exactly the job I did not want.

With this structure in place, I started to unleash some real power. I essentially sat back and watch AI agents capture business requirements, write a design deliverable, drive human sign-off, build the solution (an off the shelf CRM and Support application), and drive it through human testing, by itself. Systems Integration consultants should consider that. The agents read the documentation then used APIs and the browser to build and unit test the entire system.

Version 4: Slow and Expensive on Purpose

Version 4 closed that gap. Claude handed work to Cursor directly, and that was the first real taste of what end-to-end agentic development looks like. Then I did something that will sound unfashionable in 2026. I made it slower.

I bolted on quality gates, secondary reviews, a pre-consult before any build, and a post-build gauntlet to confirm the delivered thing matched what I actually asked for. It burned a lot of tokens. It also produced measurably better outcomes. I also wired an automated weekly retrospective that evaluated how the process itself was performing and surfaced recommendations, which we acted on every week, without fail.

If you take one thing from Version 4, the point of agents is not to go faster than a human. The point is to do the right thing with less of a human's attention. Those are very different objectives, and the gap between them is where most teams I have advised get burned. We can also talk about breaking down the discrete aspects of a task, but that is an entirely different post.

Version 5: Open Communication Beats Rigid Verbs

Version 5 is Grok Bot, offered as part of my Claude subscription. Conceptually it was the experience I had hoped OpenClaw would be, without the maintenance burden, and able to call the Claude models I relied on when needed. It also saved me from juggling dozens of live Claude sessions at once.

Adding it to the stack was supposed to be easy. It was not. The clean Claude-plus-Cursor pattern did not generalize to a more complicated topology of Product Owners, dev leads, coders, and point-solution agents. I kept finding myself defining new "verbs" the agents used to talk to one another, and the verb list never stopped growing. Every new agent meant three more verbs and two more edge cases.

So I made a judgment call. Let the agents talk openly. Ask questions, request actions, hand off work, with a shared addressing scheme and a shared idea of trust levels. Google's A2A protocol was a useful starting framework. That decision became AJAM, AJA's agent messaging platform. The impact was immediate. Cross-platform agent work got dramatically smoother. It required a lot of kernel rewriting, but it was transformational. I can now add a new agent, a replacement for an LLM that is briefly down, or a specialist for a research task, without redefining the vocabulary every time.

Version 6 Is Already Starting

Version 5 just landed. Version 6 is already beginning, with a new kernel platform and a more flexible agent-brain to really amplify agent power and flexibility.

That cadence is not a confession. In my opinion, building for flexibility is a wise step. The useful question is not "when will this settle," it is "how fast can you iterate without breaking the things that already work." Six versions in, I am still answering it.

I have skipped a lot of detail here. If you are building something similar, or are stuck somewhere I have already been, reach out. I would rather have the conversation than let you learn the same lessons slowly.