What is an agentic workflow? One person, one agent
Updated
An agentic workflow is work where an AI agent decides the next step itself. It plans, acts, looks at the result, and either carries on or comes back to you. Most explanations describe fleets of agents inside large companies. You do not need any of that. The smallest version is one person, one agent, and a list of things to do.
A plain definition
Give an AI agent a goal, not a script. The agent can use tools: search the web, read documents, edit a page, fill in a list. It picks a step, takes it, looks at what happened, and picks the next step. It stops when the goal is met, when it is stuck, or when it needs a decision that is not its to make.
That loop is the whole idea. Plan, act, check, repeat. Everything else you read about is a variation: more agents, more tools, more rules about who may do what.
How it differs from an automation
A classic automation is a fixed recipe. When a form is submitted, send an email and add a row to a sheet. Every run takes the same path. It is reliable because it never thinks, and it breaks the moment the input looks different from what you planned for.
An agent does not follow a fixed path. It chooses the path from what it finds. That makes it useful for work you cannot fully describe in advance, like finding out why a page on your website loads slowly, or which of twenty suppliers still sell the part you need. It also makes it less predictable, which is why the checking and the reporting matter as much as the doing.
How it differs from a chat
In a chat, you are the loop. You ask, the model answers, you copy the answer somewhere, try it, come back with what went wrong, and ask again. The model never touches anything. You carry every step between the conversation and the real world.
In an agentic workflow the agent carries those steps. You move from doing each step to deciding what the work is and whether the result is good enough. That is a different job, and it is closer to managing a project than to typing into a chat box.
The smallest real version
Here is one a single person can run on a Tuesday afternoon. There is a project. It has tickets. Each ticket is one problem or one piece of work, with a short title and a few lines of detail. The agent can read and write that project, and nothing else.
- Plan. You write the ticket, or the agent files one when it finds a problem. The ticket says what the work is and what done looks like.
- Act. The agent picks up the ticket, sets it to in progress, and does the work.
- Check. It compares the result with what the ticket asked for.
- Report. It writes what it did and what it found in the ticket's thread, then sets the ticket to done.
- Ask. If it needs you, it sets the ticket to blocked with a concrete question, and stops.
You read the thread, reply, and decide. No orchestration layer, no diagram with twelve boxes. The ticket is where the plan starts and where the result lands, and it is still there next month when you wonder why something changed. This is ordinary personal project management, with one extra pair of hands.
Why tickets and not the chat window
A chat session ends. Its history gets long, then gets cleared, and it lives inside one tool. That is not a good place to look three weeks later.
A ticket has a number, a status and a thread. You can read it on your phone while the agent is working. The agent can pick it up again another day. And "ticket 12" means the same thing to both of you.
Agentic workflow examples from solo work
- A website check. The agent goes through your site and files one ticket per broken link or outdated price, instead of one long message you will never finish reading.
- Research for a decision. You file "Find three venues for a 20-person workshop in May". The agent collects options, writes them in the thread with the trade-offs, and sets the ticket to blocked: "Which one should I ask for a quote?"
- Follow-ups. After a busy month, the agent reads your notes and files a ticket for each person you promised to get back to. You decide which ones matter.
- A bug in an app. You file the steps. The agent fixes it, checks the fix, and writes what it changed. You try it before it counts as deployed.
What stays with you
Handing work to an agent moves the doing. It does not move the deciding. You still choose which tickets exist, what counts as done, and what goes out into the world. The agent should ask when a choice changes scope, costs money, or cannot be undone. The guide on human in the loop for AI agents goes through where to draw those lines.
Keep the agent's access small, too. One project, its own token, revocable at any time. If it goes wrong, the damage is limited to one project, and every change it made is in a thread with its name on it.
Starting small
Pick one project. Write three tickets that are small and clear. Tell the agent where the tickets are, how to set a status, and that blocked means stop and ask. Read what comes back. Adjust the tickets, not the agent's personality. Most of the gain comes from clear tickets and a trail you actually read. The guide to using an AI agent for project management covers the setup in more detail.
If you want a place for exactly this, Very Simple Projects is a simple personal project management app built for one person and their agent: projects, numbered tickets, six statuses plus your own, and a thread on every ticket. The agent connects to one project with its own revocable token, and every status change lands in the thread with its name. It costs $0.99 a month, and the first month is free.