AI Automation, Agentic Workflows and WAT Explained
Introduction
AI is moving beyond simple chatbots that answer questions or generate text. Modern AI systems can participate in workflows, make decisions, use external tools, inspect results, and decide what to do next.
This leads to an important concept:
Agentic Workflow.
In this article, we will use a simple learning model called WAT:
W = Workflow
A = Agent
T = Tools
WAT is not the name of a specific Claude or Anthropic product. It is a simple way to understand how we can combine a workflow, an AI agent, and tools to build intelligent automation.
In the following articles, we will turn these concepts into a practical project using Claude, VS Code, Skills, APIs, databases, Git, MCP, and automated testing.
1. What Is AI Automation?
Traditional automation allows software to perform repetitive tasks automatically.
For example, imagine an online store.
When a customer places an order, a traditional workflow could perform:
Customer places order
↓
Save order
↓
Send confirmation email
↓
Reduce inventory
↓
Finish
This is automation.
The developer has already determined what should happen at every step.
Traditional automation is extremely useful, but it usually follows predefined rules.
For example:
IF payment succeeds
THEN create order
IF payment fails
THEN display error
The program does exactly what its developer programmed it to do.
2. What Is an AI Agent?
An AI agent goes further than a normal chatbot.
A chatbot usually follows this pattern:
Question
↓
AI
↓
Answer
For example:
“How should I design a database for an online clothing store?”
The chatbot explains how you could do it.
An AI agent can potentially do more:
Goal
↓
Understand the task
↓
Inspect existing project
↓
Create a plan
↓
Select a tool
↓
Perform an action
↓
Inspect the result
↓
Decide what to do next
For example, we could tell a coding agent:
Build the product described in
PRODUCT.md. Follow our project workflow, run the tests, correct problems you discover, and stop before deployment.
The agent could then inspect files, modify code, execute tests and react to the results using the tools available to it.
The important difference is:
The AI is participating in deciding how the goal should be achieved.
3. What Does “Agentic” Mean?
The word agentic describes a system in which an AI has some ability to act toward a goal instead of merely producing a single response.
An agentic system commonly has several characteristics:
- It receives a goal.
- It understands the current situation.
- It plans actions.
- It selects available tools.
- It performs actions.
- It observes results.
- It can change its next action based on those results.
- It stops when the goal is completed or human input is required.
A simplified agentic loop looks like this:
GOAL
↓
Observe
↓
Plan
↓
Choose action
↓
Use tool
↓
Observe result
↓
Goal completed?
/ \
No Yes
↓ ↓
Continue Finish
This loop is one of the most important ideas behind AI agents.
4. What Is an Agentic Workflow?
A workflow describes how work should progress.
An agentic workflow combines structured workflow rules with AI decision-making.
Consider software development.
A traditional development automation might say:
Build application
↓
Run tests
↓
Create package
↓
Deploy
An agentic workflow could instead contain:
Read requirements
↓
Inspect existing project
↓
Plan implementation
↓
Choose appropriate approach
↓
Implement
↓
Run tests
↓
Did tests pass?
/ \
Yes No
↓ ↓
Review Investigate
↓ ↓
Finish Modify code
↓
Test again
The workflow still provides structure.
But the AI agent can decide what needs to happen inside that structure.
5. WAT: Workflow + Agent + Tools
We can simplify the architecture into three parts:
W = Workflow
A = Agent
T = Tools
Together:
GOAL
↓
┌──────────┐
│ WORKFLOW │
└────┬─────┘
↓
┌─────────┐
│ AGENT │
└────┬────┘
↓
┌─────────┐
│ TOOLS │
└────┬────┘
↓
RESULT
Let’s examine each part.
6. W — Workflow
The Workflow describes:
What process should the system follow?
For a software project, a workflow might say:
1. Read requirements
2. Analyse the project
3. Create a plan
4. Implement
5. Test
6. Fix failures
7. Review security
8. Update documentation
9. Request approval before deployment
The workflow gives the agent boundaries.
It prevents us from simply saying:
“Do whatever you want.”
A good agent needs freedom to make useful decisions, but it also needs constraints.
7. A — Agent
The Agent is the intelligent decision-making component.
In our upcoming practical project, we will use Claude Code as the development agent.
Conceptually:
WORKFLOW
↓
CLAUDE
↓
Reads requirements
↓
Examines project
↓
Plans
↓
Chooses appropriate action
↓
Uses tool
↓
Examines result
For example, Claude may discover:
Tests: 18 passed, 2 failed
Instead of simply stopping, our workflow can instruct the agent to:
Read failure
↓
Find probable cause
↓
Inspect relevant code
↓
Correct implementation
↓
Run tests again
This is where the agentic behavior becomes useful.
8. T — Tools
An AI agent cannot accomplish much if it can only produce text.
Tools allow the agent to interact with other systems.
For software development, tools might include:
Claude Agent
│
├── Read files
├── Write files
├── Search project
├── Terminal
├── Python
├── Git
├── GitHub
├── Test runner
├── Database
├── APIs
└── Browser
For a business automation agent, the tools could instead include:
AI Agent
│
├── Email
├── Calendar
├── CRM
├── Database
├── Payment API
├── Inventory
└── Customer support system
This leads to an important principle:
The agent provides intelligence; tools provide capabilities.
9. A Simple WAT Example
Imagine an online clothing store receives a customer request:
“I need an elegant outfit for a summer wedding. My budget is 1,500 SEK.”
A normal search system might search for words such as:
elegant
summer
wedding
An AI shopping agent could work differently.
Workflow
Understand customer request
↓
Determine requirements
↓
Search suitable products
↓
Check inventory
↓
Check total price
↓
Recommend products
Agent
Claude interprets:
Occasion = Wedding
Style = Elegant
Season = Summer
Budget <= 1,500 SEK
Tools
The agent could call tools such as:
search_products()
get_product_details()
check_inventory()
calculate_total()
The result might be:
Summer Dress — 1,099 SEK
Evening Bag — 349 SEK
Total — 1,448 SEK
The agent used reasoning plus tools to satisfy the customer’s goal.
10. Deterministic vs Non-Deterministic Workflows
This distinction is important when understanding agentic systems.
Deterministic Workflow
A deterministic workflow follows predefined logic.
For example:
IF order received
save order
IF payment successful
send confirmation
Given the same conditions, the system follows the same programmed path.
Non-Deterministic Agentic Workflow
An AI agent can choose among several reasonable actions depending on context.
For example:
GOAL:
Build an online store
↓
Analyse requirements
↓
Choose architecture
The agent might consider:
Flask
Django
FastAPI
Node.js
For a small application, it might choose one approach.
For a large multi-tenant SaaS application, it might choose another.
Therefore, we specify:
What needs to be achieved
without necessarily specifying every detail of:
How it must be achieved.
However, non-deterministic does not mean uncontrolled.
The workflow, permissions, tests and human approvals still provide boundaries.
11. Goal + Constraints + Tools
A useful formula for agentic development is:
GOAL
+
CONTEXT
+
WORKFLOW
+
CONSTRAINTS
+
TOOLS
+
FEEDBACK
=
AGENTIC SYSTEM
For example:
Goal
Build an online clothing store.
Context
Read PRODUCT.md and the existing source code.
Workflow
Plan → Build → Test → Review
Constraints
Do not deploy without approval.
Never commit secrets.
Validate external input.
Tools
Files
Terminal
Git
Database
Tests
Feedback
Test results
Errors
Database responses
Application output
The agent can use that feedback to determine its next action.
12. Why Tests Are Important for AI Agents
Testing becomes even more important when an agent has freedom to make implementation decisions.
Suppose Claude creates a shopping cart.
The workflow says:
Implement cart
↓
Run tests
Claude receives:
18 passed
2 failed
The result becomes feedback.
2 tests failed
↓
Agent investigates
↓
Agent modifies code
↓
Runs tests
↓
20 passed
Tests therefore provide the agent with an objective way to evaluate whether its work behaves as expected.
13. Human-in-the-Loop
Agentic automation does not mean giving AI unlimited permission.
Some operations should require human approval.
For example:
Agent may:
✓ Read project files
✓ Write development code
✓ Run local tests
✓ Analyse errors
✓ Update documentation
But we may require approval for:
⚠ Production deployment
⚠ Real payments
⚠ Deleting production data
⚠ Sending mass emails
⚠ Changing important infrastructure
⚠ Publishing something publicly
This approach is called human-in-the-loop.
The agent performs appropriate routine work but stops when an important decision needs human authorization.
14. Our Practical Project: StyleFlow
Throughout this series we will use these concepts to build a practical application:
StyleFlow — an online clothing store built through an agentic development workflow.
The project will eventually contain:
StyleFlow
│
├── Products
├── Categories
├── Search
├── Product details
├── Shopping cart
├── Checkout
├── Orders
├── Database
└── Admin dashboard
Instead of manually telling Claude how to write every file, we will define the product and workflow.
For example:
PRODUCT.md
│
│ describes WHAT to build
↓
WORKFLOW.md
│
│ describes HOW work should progress
↓
CLAUDE.md
│
│ gives Claude project rules
↓
CLAUDE AGENT
│
│ reasons and makes decisions
↓
TOOLS
│
├── Files
├── Terminal
├── Git
├── Database
└── Tests
↓
STYLEFLOW APPLICATION
This will allow us to experience agentic development rather than only read about it.
15. Where Skills and MCP Fit
As our agent becomes more capable, we can give it specialized Skills.
For example:
Skills
│
├── UI Design
├── Frontend Development
├── Backend Development
├── Database Design
├── Testing
├── Security
└── Deployment
Instead of putting every instruction into one enormous prompt, the agent can use specialized guidance for particular kinds of work.
We can also use MCP — Model Context Protocol to connect agents with external tools and services.
Conceptually:
Claude
↓
MCP
↓
External Tools
│
├── GitHub
├── Database
├── APIs
└── Other services
We will explore Skills, MCP and other tools later in this series.
16. Traditional AI Coding vs Agentic Development
Traditional AI coding often looks like:
Developer
↓
Write prompt
↓
AI generates code
↓
Copy code
↓
Test manually
↓
Find error
↓
Write another prompt
Agentic development moves toward:
Developer defines goal
↓
Workflow provides rules
↓
Agent examines project
↓
Agent creates plan
↓
Agent selects tools
↓
Agent implements
↓
Agent runs tests
↓
Agent observes results
↓
Agent fixes problems
↓
Human reviews important decisions
The developer is still responsible for the product.
But the developer increasingly works at a higher level:
Define what should be built, establish constraints, provide the right tools, and evaluate the result.
17. Conclusion
AI Automation combines software automation with modern AI capabilities.
An agentic workflow goes further by allowing an AI agent to make controlled decisions while working toward a goal.
Our simple WAT model helps us understand the architecture:
W = Workflow
A = Agent
T = Tools
The Workflow defines the process and boundaries.
The Agent understands the goal and decides what action to take.
The Tools allow the agent to interact with files, databases, APIs, development environments and other systems.
Together they make it possible to build automation that can:
Understand
↓
Plan
↓
Act
↓
Observe
↓
Evaluate
↓
Adapt
↓
Continue
In the next article, we will move from theory to practice.
We will open VS Code, use Claude as our development agent, and create our first real agentic development workflow using:
PRODUCT.md → WORKFLOW.md → CLAUDE.md → Claude Agent → Tools
→ Next Article: Build Your First Agentic Workflow with Claude and VS Code