What is an agentic workflow?
Definition
An agentic workflow is a process in which a language model performs some steps, such as classifying, drafting or calling a tool, while code or configuration fixes the path: which steps run, in what order, which checks sit between them and where a person takes over. It sits between a single model call and a fully autonomous agent.
What does "agentic workflow" mean? Three uses of one term
The phrase is used in three ways, and it helps to know which one a vendor or a colleague means.
| Usage | Who uses it this way | Who decides the next step |
|---|---|---|
| A design pattern: model calls arranged along a path you wrote | Anthropic, LangGraph docs | Your code |
| A product: GitHub Agentic Workflows, coding agents running inside GitHub Actions | GitHub | The agent, inside limits set in a Markdown file |
| A loose label for any AI-assisted automation | Marketing pages | Often unclear |
The first meaning is the precise one. In Building effective agents (December 2024, so an older source, but still the primary one for this distinction), Anthropic calls both workflows and agents "agentic systems". It then separates them: workflows are "systems where LLMs and tools are orchestrated through predefined code paths", while agents "dynamically direct their own processes and tool usage". The LangGraph documentation draws the same line: workflows have predetermined code paths, agents define their own process.
This page uses the first meaning and covers the GitHub product in its own section.
How does an agentic workflow work?
You write the skeleton, and the model fills in steps that need language skills. Anthropic's post names five recurring shapes:
| Pattern | What your code fixes in advance | Where it fits |
|---|---|---|
| Prompt chaining | The sequence of steps, with programmatic checks ("gates") between them | Tasks that split cleanly into fixed subtasks |
| Routing | The categories, and which handler each one goes to | Inputs that fall into distinct types |
| Parallelization | How the input is split, or how many attempts are compared | Independent subtasks, or voting for confidence |
| Orchestrator-workers | Only the frame: a central model decides the subtasks | Work where the subtasks cannot be listed upfront |
| Evaluator-optimizer | The loop: one call drafts, another critiques | Output with clear criteria that improves with feedback |
Orchestrator-workers is the point where a workflow starts to behave like an agent, because the model, not your code, picks the subtasks. If you want the fully model-driven loop, see the ReAct agent entry.
Agentic workflow vs AI agent: which one do you need?
| Question | Agentic workflow | AI agent |
|---|---|---|
| Can you draw the steps before the run? | Yes | No, the model plans as it goes |
| How does it fail? | A step returns bad output and a gate catches it | It takes a wrong turn several steps deep |
| How do you test it? | Each step, plus the path | Whole runs, repeated, because paths differ |
| Typical cost and latency | Bounded by the number of steps | Grows with the number of loop turns |
Anthropic's advice is to find the simplest solution that works and add complexity only when it pays. It warns that agentic systems often pay for better task results with extra latency and cost, and that for many applications a single well-prompted model call with retrieval is enough. A workflow is the usual middle step: more capable than one call, more predictable than an open loop.
Example: a refund workflow in Python
The model classifies and drafts. The code decides the order, checks the draft, caps retries and hands off to a person. The llm() stub lets it run offline. The file below is the one we executed locally under Python 3, unchanged.
# A fixed-path agentic workflow: the code decides the order of steps, the model fills them in.
def llm(prompt): # stub so the example runs offline; replace with your model client
if prompt.startswith("Classify"):
return "billing"
return "We refunded the duplicate charge on order 1182. It reaches your card in 5 business days."
def gate(reply): # programmatic check between steps
return "order" in reply and len(reply) < 300
def handle(ticket):
route = llm(f"Classify as billing, shipping or other: {ticket}") # step 1: route
if route != "billing":
return ("human", "sent to the support queue")
for attempt in range(2): # step 2: draft, at most twice
reply = llm(f"Draft a reply to this billing ticket: {ticket}")
if gate(reply): # step 3: gate
return ("auto", reply)
return ("human", "draft failed the check twice") # step 4: escalate
print(handle("I was charged twice for order 1182."))
Output: ('auto', 'We refunded the duplicate charge on order 1182. It reaches your card in 5 business days.'). Every exit is known in advance, which is what makes the path testable.
What are GitHub Agentic Workflows?
GitHub uses the term as a product name. GitHub Agentic Workflows became generally available on October 28, 2026 for GitHub Free, Team and Enterprise. You describe a repository task (issue triage, CI failure analysis, documentation updates, test writing) in a Markdown file, and the gh aw CLI compiles it into standard Actions YAML. The default engine is GitHub Copilot CLI, which needs a Copilot license; you can bring another coding agent instead.
The Markdown file declares triggers, permissions, tools and safe-outputs. In GitHub Next's example, the agent has no write permission, and the safe output allows at most one new pull request. Agents run read-only by default, in a sandboxed container behind a firewall, and a threat detection job scans proposed changes before they apply.
By the design-pattern definition above, this is closer to an agent inside a fenced workflow: the trigger and the permitted outputs are fixed, the steps in between are not.
What to check before running one in production
- A gate after every model step. Format, length and required fields in code, before the next step runs.
- A retry cap and an escalation path. Every loop ends, and the last exit is a person.
- Least privilege for each step. A drafting step needs no tool that sends or deletes. The AI guardrails entry covers input, output and tool checks.
- Tests per step and per path. Our guide on how to build AI agents covers evals and supervision in more depth.
Redesigning a process around steps like these is the core of our agentic process transformation service. At SDCLabs, agents write first drafts of specs, code, tests and reviews, inside workflows that senior engineers design and supervise.
Sources
- Building effective agents, Anthropic, 2024-12-19
- Workflows and agents, LangChain (LangGraph docs), 2026-11
- GitHub Agentic Workflows generally available, GitHub Changelog, 2026-10-28
- Agentic Workflows, GitHub Next, 2025-08
Frequently asked questions
What is the difference between an agentic workflow and an AI agent?
In a workflow, your code decides which step runs next and the model only fills in steps. In an agent, the model decides its own next action and tool calls until it judges the task done.
What is agentic workflow design?
Choosing the fixed parts before the model runs: the steps, the routes between them, the checks after each step, the retry limit and the hand-off to a person. Patterns such as prompt chaining, routing and evaluator-optimizer are common starting shapes.
Is ChatGPT an example of an agentic workflow?
A plain chat turn is not: it is one model call that answers a prompt. It becomes agentic when the product chains steps or lets the model call tools to complete a task, which is a design choice of the app around the model.
Do you need a framework to build an agentic workflow?
No. A workflow is ordinary code that calls a model at some steps, as the Python example on this page shows. Frameworks such as LangGraph add persistence, streaming, debugging and deployment support, which help once the graph grows.
Read next
Sergey AlmyashevChief Operating Officer14+ years in QA, automated, exploratory and performance testing, and continuous integration and delivery within Scrum, helping teams in product and outsourcing companies organize teams, processes and tools.LinkedIn