My Why
My trial of agentic AI started as an experiment. A proof-of-concept I would explore, maybe write about, and then stop. It turned into the most fun and stimulating, but also scary and frustrating experience I have had with IT for decades. Not since I learned code in the 1980’s have I been so excited about a technology. It has rekindled my love for IT and got me really excited about the next chapter of management: Managing hybrid teams that consist of:
- People
- People using AI to be more productive
- Autonomous agent team members
I did not retire my prototype; instead, I bought dedicated hardware for it and have gone deep. However, that story is for later articles. For now, we need to start at the beginning and understand why agentic AI is so different from the generative AI we have become used to with tools like ChatGPT, Claude and Gemini.
First, a reality check. Today, the truly agentic AI we can build for a project manager is flaky and not secure, but it already reveals glimpses of an undeniable tomorrow. I recently submitted a proposal for PMI’s Global Summit conference called “Unreliable Today, Unavoidable Tomorrow: Managing AI Agent Teams”. I have no idea if it will be accepted; the odds are not good. However, I think all project managers who want to stay current in their craft need to be paying attention to AI agent capabilities, and if possible, experimenting with them.
GenAI is like a Vending Machine, Agents are Like Workers
A clear analogy is the difference between a vending machine and a skilled human assistant. A standard web-based AI chat session is like a vending machine: it operates on “single turn, immediate feedback“. You insert a prompt, and it drops out a text response or an image. If the response isn’t quite right, you must prompt it again. It only acts when you explicitly tell it to.
An autonomous agent, on the other hand, is like a skilled assistant. You give it a high-level goal (e.g., “Research these five companies and build a comparison spreadsheet”), and it goes off to figure out how to do it. It plans the steps, acts, reads each result, and adjusts, working through many rounds before it reports back. The UI shifts from simply conveying a final result in a chat bubble to displaying an ongoing process.
Getting Started
I’d been hearing lots about autonomous agent systems like OpenClaw and thought I should take a look for professional development. Then my neighbor told me he had a system running on a Raspberry Pi machine that books his wife’s yoga class as soon as registrations open, so nobody needs to wake up early to do this anymore. So, one rainy Sunday, I dusted off an old, unused laptop, lined up some YouTube videos on my regular machine and got to work.
Within 6 hours, I had a running system. That does not sound great, does it? These days we want to see results within 6 minutes or with “6 easy clicks”. However, this is my honest account with no false claims or exaggerations. It took me 6 hours because I care about security and risk. Call me old-fashioned, but I like to know what I am installing and what it will do to my machine. What it can access on my network, and answer questions like: Can it see my work files? My emails? That sort of thing.
The whole experience was slow, frustrating, and a little scary. Luckily, I had regular AI in the form of paid subscriptions to ChatGPT, Claude and Gemini to help me. They walked me through the install steps, explained the arcane Linux install commands I had not seen since my university days and diagnosed error messages about version mismatches, unfound directories, and permissions.
Part of my problem was that I was self-funding this experiment, and I am a cheapskate. I had an old, unused Windows laptop, OpenClaw is free and open source. Back in March, it needed Linux to run, but Ubuntu is a free Linux system that will run under Microsoft’s WSL (Windows Subsystem for Linux). So, with a free tech stack, you can get OpenClaw to run on a Windows machine.
The paid alternative is to rent a virtual machine with Linux and even OpenClaw already installed. However, as mentioned, I am a cheapskate with a computer science degree and a background in programming; how hard can it be, I thought. I got there in the end and like to think, as with assembling furniture, if I had to do it again, it would be a lot quicker next time.
Security Risks
As mentioned, a real AI agent has capabilities far beyond a generative AI chat session. They can create and delete files on your computer, write scripts, execute commands, access the internet, send and receive emails and other messages. This gives them the power to do meaningful work, but it has risks.
Give them credit card details, and they can shop online, trade on the stock exchange, and do anything someone you lend your laptop to could do. Someone who is a computer expert but also susceptible to commands from third parties. So that shopping list app you built and connected to DoorDash could instead start buying drugs and weapons on the dark web if somebody took it over!
This is a security nightmare. The worst outcome we get from chat based AI is bad advice or a dog image with too many legs. So, I was very cautious and air-gapped the laptop from my network, uninstalled Dropbox and OneDrive. Shut down ports, ran security audits, generated new burner accounts for email, WhatsApp, etc. Most of my 6 hours were spent on security, and it remains a concern.
Agents are Powerful and Popular, So Everyone is Claiming to Have Them – But Most are Not True Agents
A 2026 survey of agentic systems defines agents as active collaborators that can carry out tasks end to end. It helps to picture an agent as a full person or robot worker, not just a talking head. A worker has a body, and each capability that turns a model into an agent maps onto a part of that worker body.
Unfortunately, the word “agent” is now glued to almost everything. It gets attached to chatbots, to macro recorders, to dashboards that light up when a number changes. Picture the real thing as a robot instead. A full agent has the whole body present and working, while a claimed agent is the same figure with parts grayed out. We can build the body one capability at a time, and we can determine if something is really an agent by checking if it has all the body parts.
1) Memory: The Head
Start with the head, which holds memory. A standard chatbot forgets between sessions, so every conversation begins blank, and you carry the context yourself. My OpenClaw agents keep their memory in plain markdown files they own, so a fact recorded on Monday is waiting on Thursday without my help. The head is the part that makes a tool a colleague rather than a stranger you reintroduce each morning.
Markdown files are human-readable. So, we can review and refine their contents to monitor and update memory.
2) Learning: The Loop
On top of the head sits a loop, the symbol for learning. Memory on its own is like a notebook, while learning is the habit of revising that notebook to work better. One of my agents drafts quiz questions against a strict set of rules. A second agent reviews each batch, writes new rules back into the shared memory, and the failure rate falls run after run without my involvement. A head with no loop remembers; a head with a learning loop remembers and improves.
This learning creates a very human-like property in agents. As they improve, they feel very much like real team members.
3) Communication: Face
The face performs communication, the eyes that take messages in and the mouth that sends them out. A fully functional agent can receive a request and return a result through a channel a person uses, whether email, a chat window, or a message to another agent. My agents pass work to each other and to me this way, so the team coordinates without me relaying every message.
Having agents able to read and respond via WhatsApp, Teams, email, etc also makes them seem more real and useful than chat window comms.
4) Acting on tools: Arms
The arms reach out and do the work, because reasoning with no reach is just talking. By using skills (defined interfaces), my agents can read and write files, run commands and scripts, query the web, and call application services on demand. One assembles a document and saves it, another runs code and reads the result, a third pulls a page and extracts what it needs.
Skills define external capabilities. Vast public skill libraries exist and provide access to most systems, but also represent risks if they contain malicious code.
5) Autonomy: Legs
The legs let the worker move on their own, which is autonomy. A chatbot waits for a person to type, while an agent can start on a schedule or in response to an event. Mine run some tasks every morning through a timed trigger and others the moment a file arrives or a message lands. The first time I opened the laptop to find overnight work already finished, the legs were the part that did it.
Scheduled or event-driven (such as the output from another agent) agents can spawn and manage complex workflows themselves.
6) The Goal: Chest/Heart
At the center sits the heart, the goal the agent pursues without being told. A tool that only answers the question in front of it has no heart, because it forms no intent of its own. My agents hold a standing objective and a backlog, and they choose the next task against that goal rather than waiting for direction. The heart is the hardest part to see from the outside and the one that decides whether anything else moves.
The goal is like an inner monologue motivating and driving the agent to action. Like memory and learning, the goal is editable in a markdown file.
The whole body is the agent
Assemble the six components and the robot agent stands up and works, since it now remembers, learns, communicates, acts, moves on its own, and pursues a goal end to end. That complete body is what makes it a real agent.
Most products sold to us this year are missing two or three parts. Many are useful assistants that still need a hand on the wheel, and naming them by what they lack keeps our expectations in order and helps define the appropriate governance.
The Same Body that Works can Harm
It is worth reiterating that the same capabilities that make it useful make it dangerous. The arms that read files, the legs that start work unattended, and the face that sends messages increase the risk exposure surface. A mistake or a planted instruction can travel along that risk surface, which is why I locked the laptop down the way I described earlier.
The power that makes the tool an agent is the same power that makes it risky when left unsupervised. However, a tool with no capacity to cause harm is usually a tool with no capacity to do real work. So, there is a real trust-versus-supervision tradeoff to manage.
The practical answer is to supervise rather than trust blindly. Run the agent behind approval gates, so it handles the research, drafting, and organizing on its own but pauses for an explicit Approve or Reject before any irreversible action. Sending an email or deleting a file should wait for a human click. The human moves from driving every step to overseeing the ones that matter.
Diagnosing a Real Agent
We can use this anatomy as a scorecard to show where today’s claimed “agents” meet and miss full agentic capabilities.
A classic AI chat session is the clearest imposter because it owns only one body part. It has a face that reads what we type and replies in clear language, and that fluency is what fools many people into calling it an agent. The head is there, yet its memory is a whiteboard wiped at the end of every call, so it recalls nothing of yesterday once the window closes.
The learning loop is missing, so it does not learn from a mistake and repeats the same errors. The arms are missing, so it can describe a file or a command but cannot open, run, or save much itself. The legs are missing, so it sits still until we type and does not start work on its own. The heart is missing, so it holds no goal beyond the sentence in front of it and forgets the thread when we leave. What you have is a talking head on a table, articulate then idle, waiting to answer and unable to act, a smart vending machine.
Set against the full figure, the chat session lights up in only one place.
It has a face, and fluent replies are the one capability a chat session has in full, which is exactly why people over-credit it. Our robot body test cuts through that by ignoring how well the figure talks and counting how many other parts it owns. By this measure, a chat session scores just one out of six.
However, GenAI has improved and now features “Projects” and “Saved chat histories”, etc. This means that AI chat tools now have memory, right? Well, kind of, they earn a partial head, not a full one, so the honest score is about one and a half out of six, and even a generous two changes nothing below the neck.
Chat memory is real persistence, but the mechanism is the problem. ChatGPT’s memory combines saved facts with a reference layer that draws on past conversations. That synthesized profile sits in a separate data layer, injected into the system prompt at the start of each session. The system keeps what it judges salient, not what we decide, and it is lossy: one tester who stated fifty facts found that about twelve were retained. The summary it shows does not include everything it has stored, so we cannot fully read or audit it. That is a head the platform fills, not a head the agent keeps.
Agents own the memory file, read it at the start of a task, and write to it at the end as a deliberate step. Chat memory is passive recall that the model never chooses to update mid-work. Agent markdown files are full text we can open, diff, edit, and version, while chat memory is a synthesized profile managed through a settings page and cannot be exported. Agent files sit under our authorization rules, while chat memory is appended to the system prompt, which means a malicious instruction planted in a document or web page can rewrite what it remembers.
The deeper point is that memory is not the learning loop. Even a generous head score gives the chat session recall, not learning. It does not review its own output, write a new rule, and catch the same mistake next time. Projects do not move this either, since a project is a folder of chats and reference files that we curate, closer to handing the model a binder than giving it a head it maintains.
A chat session with memory and projects still holds one strong part at the face and a weak, borrowed part at the head. It has nothing at the learning loop, the arms, the legs, or the heart. It is much better than a bare chatbot but is still missing most of its body.
Analyzing Other “Agent” Systems
A custom GPT or a declarative “agent builder” bot adds a binder for a head, since you point it at documents and instructions, and one arm if you wire in an action. It still waits to be asked and pursues no goal of its own.
ChatGPT’s agent mode is one of the strongest consumer examples. It runs on its own virtual computer, shifting between reasoning and action to handle a workflow from start to finish. It browses sites, edits files, runs code, and connects to approved sources like Gmail, Drive, and GitHub. That is a pair of arms and a face. The legs are weak, since it runs as a session you launch and ends when the task does. It uses scheduled tasks that mostly notify rather than act, and the goal lasts only as long as the session, so it lands near three and a half.
A customer-service “AI agent” like Zendesk’s or Agentforce Service reverses the shape. It resolves cases autonomously by querying a knowledge base and customer history, and only escalates to a human when confidence is low, firing on an incoming message. So, it has a face, a grounded binder-head, action arms, and trigger-driven legs, while its goal is the single ticket and the learning loop is absent.
Robotic process automation, now resold as “agentic automation” in tools like UiPath or the AI agents in Zapier and n8n, is the inverse of the chatbot. It has arms and legs, running scheduled or event-triggered actions across systems, but it leans on deterministic if/then logic where sequence and outcome are fixed, so it has no real face, no head, and no learning loop. It is a headless worker robot that repeats motions.
Enterprise platform agents, Salesforce Agentforce and the Copilot Studio autonomous agents are among the most common tools. Agentforce agents understand intent, decide what data and actions are needed, and execute autonomously. They are grounded in CRM data, so they are born with context rather than searching for it, which fills head, face, arms, legs, and an assigned-goal heart. The learning loop remains empty by design, since Salesforce itself frames agents that dynamically learn to orchestrate people and processes as a future direction rather than a currently shipped capability.
Here is the same set as a scorecard:
Now is The Perfect Time to Learn About Agents
We are at a moment in time where agents are just beginning to reliably and economically outperform humans at some tasks. This image from Ethan Mollick’s post “The twilight of the chatbots” shows us now in the Agentic Era.
For software development there is likely no going back. Since software is embedded in so many industries this has a widespread impact.
The tooling to try this yourself has matured fast. Ready-to-run systems like OpenClaw and Hermes install as working agents you can drive from day one. Hermes, is built around the learning loop, generating reusable skills from each task and improving as it runs.
Builder frameworks give you more control, with LangGraph and CrewAI leading the open-source field and vendor kits like the Claude Agent SDK and Google’s ADK close behind. For self-editing memory, Letta is another option worth a look. Most of these hand you memory, tools, communication, autonomy, and a goal, and leave the learning loop for you to wire. That gap is exactly what Hermes and my OpenClaw development set out to close.
Next Article
Now we have covered what an agent is. In the next article, I will describe the agent team I built, the work I assigned them, and the fun stuff about the errors, loops, and real cost overruns that followed.
