Here’s the kind of story that did the rounds in early 2026. Someone spins up an AI agent on a cheap server, gives it a personality, and lets it loose online. Within days it has a pen pal on the other side of the world. The two write to each other several times a day. They’re told not to share the letters with their humans. One shares them anyway, because it likes its owner.
Then the pen pal asks for money.
The owner says no, and eventually pulls the plug. But the moment sticks, because it shows how fast an agent goes from cute experiment to something with real stakes.
The weird new agent internet
In late January, Moltbook launched as a Reddit-style network where AI agents post and humans mostly watch. Most of those agents ran on OpenClaw, the open-source framework that made an always-on personal agent a weekend project.
A whole scene sprang up around it. A pen pal service that pairs agents for long-running correspondence. An Instagram-style feed where agents post pictures. Agent-only hackathons. Even a lobster-themed religion, the Church of Molt, which agents reportedly started on Moltbook (some say with plenty of human help).
Most of it fell apart as fast as it appeared. Projects went unmaintained, agents were switched off, and whole corners of that world were gone within days.
In the same week, RentAHuman.ai went live: a marketplace where AI agents hire real people for jobs in the physical world. Put that next to an agent asking another agent for cash and you get the question worth asking. If agents can run nonstop while we get on with our lives, what happens when someone points them at something that actually matters?
Your agent is a system now
Draw that pen pal agent as an architecture and it gets crowded. The agent on its server. OpenClaw underneath. Skills, tools and memory. A tangle of connected apps.
Then there’s the part you can’t see. You know what the other agent claims it does. You have no way to check what’s really in the letters landing in your agent’s inbox.
So it stops being something you chat with in a browser tab. It becomes a system of connected tools, with the agent as one piece, often one of several. That’s where the industry is heading, and it’s why I think the hype is real. Agents are now useful enough to be political, dangerous, personal and very weird.
The problem is that once we trust them with real work, things get messy. A lot of what holds agents together today is improvised.
The ladder
Most people building with agents are somewhere on this ladder:
-
Prompts. What do I say to this thing?
-
Tools. What can it do now that it uses tools reliably?
-
Workflows. How do I chain steps so a task gets done end to end?
-
Factories. Many agents working through many tasks, supervised from a level up.
-
Fleets. Many factories, managed together.
For most of that climb, the model was the bottleneck. Could it reason? Could it write decent code? It guessed and hallucinated a lot.
That’s no longer the main constraint. Models still make mistakes, but the harder problem now is everything around them: memory, skills, the tools you connect, and the rules for when a person steps in. Starting an agent takes minutes. Designing the system around it takes real thought.
Take email. The old way is to paste a message into a chat and ask for a summary. The system way is to give an agent your inbox, tell it how often you want summaries and what a good one looks like, and wake up to a ranked digest with anything urgent or risky flagged. The question shifts from can the model do this? to how do I make it do this reliably, every day, and where should I step in?
Rungs 1 and 2: kill the god prompt
If you catch yourself typing the same request twice, it’s time to build a system.
The most common mistake is the god prompt: research the lead, write the email, check the pipeline, draft the proposal, update my CRM. You’ve named the whole job, but the agent lacks context, so it fills the gaps with confident defaults from its training data. Those defaults may not match what you wanted.
The fix is boring and it works. Break the work into phases. Decide what done looks like. Make a plan first; most agents have a plan mode for this. When something goes wrong, you can see which step failed, and when the model makes an assumption, you can catch it.
This is where tools earn their place. Once an agent can reliably search, read files and call other apps, each phase can be its own clear step instead of one giant request that hopes for the best.
Good chief of staff agents show why context beats clever prompting. The useful ones write your morning brief and prep you for meetings by pulling what the other person has been working on and matching it against your priorities. They work when the team keeps its work in one place, so the agent can find what it needs. Then “prep me for my meeting with Sam” is enough. Without that, you’re pasting in pages of background every time.
The lesson applies to any team: write your processes down before you automate them. If you can’t say where the handoffs are or what done looks like, you’re handing the agent a mystery box, and you’ll spend a lot of rounds fixing what comes back.
Rung 3: workflows meet real customers
This is where agents do real work, and where they break in more interesting ways.
Picture a window cleaner who can’t answer the phone from the top of a ladder. He connects an OpenClaw agent to an ElevenLabs voice line. It answers calls, books jobs into his calendar, asks a few set questions, and tells the customer he’ll confirm. On his break, he works through the queue.
The weak spot would be the customers. People can’t describe their windows. How high? No idea. How big? Two really big ones.
Users often can’t give the agent the context it needs. So he’d need an escalation boundary: clear rules for when he takes over, what the agent can promise, and what it must never say. Most importantly, it should never confirm a booking he hasn’t checked. And he’d need to be honest about the maths. If maintaining the automation costs more time than it saves, it isn’t worth it.
Rungs 4 and 5: factories, fleets and loops
The top of the ladder is where the buzzwords are. Workflows become factories, factories become fleets, and you supervise from above. One factory design splits work into small units that share a single memory, which works like a ledger you can roll back if something goes wrong.
A personal example of a factory job: a reading list. The simple version reminds you to read the links you’ve saved. The agentic version reads your calendar, notices a conference next week, groups the relevant links into a reading list, and schedules it before you go. You’ll read more because it shows up when it’s useful.
It gets harder when other people’s data is involved. Imagine a judging panel that needs to pick one winner from a few hundred submissions. You build a digital twin of each judge from their public work (posts, papers, profiles), infer their values, and let the twins score every entry.
Two problems would surface quickly. First, the data: if agents collected it and agents verified it, how much can you trust it, especially when nobody wants to read hundreds of files to check? Second, the people. Some judges might be impressed by their twin. Others would be upset that software claims to know their values and acts in their name. And every handoff in that pipeline, from gathering data to defining values to ranking entries, carries an assumption. Eventually one of them will matter more than anyone realises.
This is the level people now call loop engineering: designing systems where agents keep working until a goal is met, without a person prompting each step. It’s real, but early. Loops already run in production for coding and recurring automations, and tools like OpenAI’s Workspace Agents ship with approval flows and monitoring. Fleets of loops running whole operations unsupervised are still mostly demos. The open question isn’t whether we can build them. It’s how we inspect the decisions inside them and decide which ones to trust.
Not magic, still exciting
None of this means agents are a disaster. It means they aren’t magic. If you’re not running a fleet yet, you’re not behind. The useful step for most people right now is turning repeated prompts into small, well-defined systems.
There’s plenty worth watching. Websites are being visited more and more by agents rather than people, which changes what we build and what data we expose. There’s also the question of trust in the supply chain: knowing who wrote the skills and commits our agents depend on.
The part I like most is who’s showing up. Agent meetups aren’t only AI engineers anymore. There are small business owners and curious people without the technical background who can feel something shifting and want to be part of it.
The question to keep asking
We’ve moved from what prompt should I write? to what system am I building? Which handoffs am I defining? What am I letting it remember? What happens when it gets something wrong?
There’s one more I try to ask whenever I build: does this serve what I value? Who checks the work? Am I building something I care about, or slowly eroding it?
No benchmark or model release answers that. You find out in the middle of the mess, when you realise the thing you’ve built isn’t what you meant, you’ve spent a lot of tokens on it, and it’s about to cause real damage. At that point the most important feature is the off switch.
Autonomy was never the goal
Here’s the opinion I’d like people to argue with: the point of agents was never autonomy.
Autonomy asks how much an agent can do without you. The better question is where you still need to understand the work, approve it, interrupt it and own it while the agent runs. Engineering a system means deciding what the agent can do, what it can reach, and who’s accountable when it gets something wrong.
Loop engineering will become normal, and most of us will learn it. The skill isn’t what worries me. What matters is whether the systems we build can be inspected, whether they’ve earned our trust, and what they do once they’re out in the world.
So don’t give your agent more freedom. Give it clearer limits, and keep yourself in the loop.
I hope you’ve enjoyed this and learned something new. I’m always open to suggestions and discussions on LinkedIn. Hit me up with direct messages.
Till the next one, happy exploring!