Lesson 01 · AI Teaching Course
From LLM
to agent workflow
By the end of this lesson, students should be able to separate mechanism, model, agent loop, implementation, orchestration, and workflow.
agenda
Today’s teaching path
01Why AI terms get blurred8 slides
02Neural network foundation5 slides
03LLM layer7 slides
04Agentic layer10 slides
05Implementation and orchestration9 slides
06IDE workflow, glossary, recap11 slides
part 01
Why does this topic become confusing so fast?
Because several layers are usually introduced at the same time.
mechanism
model
behavior
tool
workflow
confusion 1
Model is not the same as product
confusion 2
Chat is not the same as agent
confusion 3
System name is not the same as workflow layer
Named tool
A concrete implementation or package.
Workflow
The sequence of steps that gets work done.
Layering
We need both, but we should not confuse them.
discipline
The classroom rule for every term
Ask: What layer does this belong to?
Mechanism?
How learning happens.
Model?
What kind of system is trained.
Workflow?
How work is actually carried out.
preview
The staircase we will keep using
2language-focused neural network
3loop with tools and action
4Open Claw / Hermesimplementation
5workflow coordination layer
6IDE experience of the stack
neural network
Definition
A neural network is a parameterized layered system that learns patterns from data by adjusting many internal weights.
neural network
A simple anatomy
input features
weighted transformation
prediction
neural network
Neural networks do more than language
Audio
speech and sound tasks
Control
ranking, robotics, recommendations
neural network
What it is not
Not automatically an LLM
language is only one application
Not automatically a chatbot
chat is an interface pattern, not the mechanism itself
llm
Definition
An LLM is a neural network trained on large amounts of text and optimized to predict the next token in a sequence.
llm
The small idea behind the big effect
Read context
take prior text as input
Predict token
estimate likely continuation
Repeat
build output step by step
llm
What plain LLM use often looks like
Rewrite
summarize or transform text
Draft
produce candidate content
llm
What an LLM is not
Not just the chat window
the model can appear in many shells
Not automatically an agent
a strong answer is still just an answer if no action loop exists
llm
A plain chat example
Prompt:
"Explain the difference between an LLM and a neural network."
Output: a text answer. Useful, but still a one-step interaction.
transition
So what changes next?
The model stops being only a responder and starts participating in a task loop.
part 04 · behavior
Step 3: agentic LLM
An LLM inside a broader loop of planning, action, observation, and revision.
agentic llm
The basic loop
agentic llm
Planning gives shape to the task
Break down
split a larger goal into steps
Prioritize
choose a sensible order
Track progress
know what has been done
agentic llm
Tool use extends what the model can do
Read
inspect files or documents
Search
retrieve new information
Execute
run commands or operations
agentic llm
Memory helps the loop stay coherent
agentic llm
Observation closes the loop
After action, the system must inspect what happened. Without observation, there is no meaningful adjustment.
agentic llm
Revision is the point of the loop
A multi-step system should learn from each step instead of repeating the first idea forever.
agentic llm
Plain LLM vs agentic LLM
| Dimension | Plain | Agentic |
|---|
| Mode | answer prompt | run a loop |
| Tools | usually none | often used |
| Memory | mostly current turn | task state may persist |
| Goal | produce reply | move task forward |
agentic llm
The risk also changes
Plain mode risk
bad or misleading answer
Agent mode risk
bad answer plus bad action
Teaching point
more capability means more need for review
interactive
Mini lab: compare model mode and agent mode
Plain model
User asks for an explanation. The system returns text. Useful, but single-step.
Agent loop
User gives a task. The system reads context, chooses actions, checks results, and continues.
What changes?
The model is no longer only speaking. It is participating in a task process with tools, memory, and feedback.
part 05 · implementation
Step 4: concrete agent implementations
Now we move from the behavior pattern to named systems that realize it.
implementation
Open Claw in this lesson
Why this matters
It makes the agent package visible as a system, not just a name.
Teaching role
Use it as one concrete implementation example, not as the theory itself.
implementation
Hermes agent in this lesson
Treat Hermes the same way: as an implementation-layer example, not as the whole theory of agents.
implementation
Important boundary
Open Claw and Hermes are examples of implementation, not theory labels like “neural network” or “LLM.”
implementation
Example task inside an implementation
Goal:
"Read the lesson folder, revise the handout, and verify the structure."
part 06 · orchestration
Step 5: Harness
Harness belongs to the orchestration or workflow coordination layer.
harness
What Harness does
Coordinates steps
routing, retries, sequence
Supports stability
keeps the workflow more usable and structured
harness
What Harness is not
Not the model
the model still does the language reasoning
Not the whole user workflow
it supports the workflow, but is not identical to the end-user experience
interactive
Interactive stack explorer
Mechanism
Neural network: the broad learning engine underneath many systems.
Model
LLM: a language-focused neural network trained on text.
Behavior
Agentic LLM: the model working inside a loop of action and feedback.
Implementation
Open Claw / Hermes: concrete packages that realize the agent pattern.
Orchestration
Harness: the coordination layer that helps the system run reliably.
Workflow
CodeX → Cline: the user-facing experience inside the IDE.
part 07 · use case
Step 6: IDE workflow
Now the full stack becomes visible to a human doing real work.
ide workflow
A simple IDE workflow path
The IDE is where the stack becomes a visible human-agent workflow instead of just a model demo.
ide workflow
Where CodeX fits
Treat CodeX here as part of the user-facing coding workflow layer around the model and tools.
ide workflow
Where Cline fits
Treat Cline as another concrete workflow example inside the IDE environment where an agent-like experience becomes visible.
ide workflow
The human still matters
Request
the user sets the goal
Review
the user checks the output
Responsibility
the user decides what to accept
example
Beginner example
“Explain the difference between an LLM and a neural network.”
Good for plain model use.
example
Slightly advanced example
“Open the lesson folder, revise the handout, and verify the structure still matches the staircase.”
Good for agent workflow discussion.
glossary
Glossary, set 1
Tokensmall chunk of text used by the model
Promptinput or instruction given to the model
Toolexternal function or service the system can call
Looprepeated cycle of action and response
glossary
Glossary, set 2
Memorystored state used across steps
Orchestrationlogic that coordinates workflow execution
Workflowpractical sequence that produces an outcome
Implementationconcrete system package realizing a design
recap
Return to the staircase
3loop with planning and action
4Open Claw / Hermesimplementation
6CodeX → Clineworkflow use case
recap
Five takeaways to remember
Neural network is the broad mechanism.
LLM is a language-focused model on that mechanism.
Agentic LLM means the model is inside a task loop.
Open Claw, Hermes, and Harness belong higher in the system stack.
IDE workflows are where the whole stack becomes visible.
class check
Exit ticket
Question
“An agentic LLM is an LLM plus ______.”
Good answers
loop, tools, memory, stepwise action, observation, revision
close
Lesson 01 complete
The goal was not to memorize names. The goal was to learn a clean way to sort the names.
mechanism
model
behavior
implementation
orchestration
workflow