Introduction to Agentic AI
From answering questions to taking action — AI that actually does the work.
A chatbot answers your question. An AI agent takes a goal, decides on the steps, uses tools to carry them out, and checks its own progress until the goal is done. That shift — from answering to acting — is what “agentic AI” means, and it’s rapidly changing how DevOps and engineering teams work.
🎯 Learning Objectives
By the end of this lesson you will:
- Understand what a large language model (LLM) is, at a high level
- Know the difference between a chatbot and an agent
- Understand the agent loop: reason → act → observe
- See where agentic AI fits into DevOps
LLMs in One Minute
A large language model is a system trained on vast amounts of text to predict and generate language. Given some input (a prompt), it produces a useful response. Modern LLMs can write code, summarise logs, explain errors, and follow instructions.
💡 The mental model
Think of an LLM as an extremely well-read assistant that reasons in text. It doesn’t “know” live facts about your systems unless you give it that context — which is exactly what agents and tools do.
Chatbot vs Agent
| Chatbot | Agent | |
|---|---|---|
| Input | A question | A goal |
| Output | An answer | Completed actions |
| Tools | None | Can call tools/APIs |
| Steps | One turn | Many steps, looping |
| Example | “How do I restart a pod?” | “Find and restart the crashing pods” |
The agent doesn’t just tell you what to do — given the right tools and permissions, it can do it.
The Agent Loop
An agent works in a cycle until the goal is met:
┌──────────────────────────────┐
▼ │
1. REASON → 2. ACT → 3. OBSERVE ─┘
(plan next (use a (read the
step) tool) result)- Reason — decide the next step toward the goal.
- Act — call a tool (run a command, query an API, read a file).
- Observe — take in the result and update the plan.
It repeats this loop, adapting as it goes, until the task is complete or it needs human input.
Where It Fits in DevOps
Agentic AI is showing up across the DevOps lifecycle:
- Incident response — summarise alerts, correlate logs, suggest likely root causes.
- Code & config — draft Dockerfiles, pipelines, and Terraform, then explain them.
- Operations — triage tickets, generate runbooks, answer “why is this failing?”
- Review — flag risky changes and security issues in pull requests.
⚠ Agents need guardrails
An agent that can act can also act wrongly. Production systems require guardrails: least-privilege access, human approval for risky actions, and full audit logs. Never give an agent unrestricted power over live infrastructure.
See the Idea in Code
At its core, an agent loop is simple. This pseudocode captures the shape:
goal = "Find why the checkout service is erroring"
while not done:
thought = llm.reason(goal, history) # decide next step
action = thought.tool_call # e.g. read_logs("checkout")
result = run_tool(action) # execute it
history.append(result) # observe
done = llm.is_goal_met(goal, history) # check progressThe LLM provides the reasoning; the tools give it the ability to actually inspect and change the world.
🧪 Hands-on Lab
Design an Agent Loop on Paper
- Pick a DevOps goal, e.g. “diagnose a failing deployment”
- List the tools the agent would need (read logs, list pods, describe events)
- Write out three iterations of reason → act → observe
🧠 Knowledge Check
What is the key difference between an AI agent and a chatbot?
What are the three phases of the agent loop?
💼 Interview Preparation
How could agentic AI help a DevOps team, and what are the risks?
Summary
You now understand LLMs at a high level, how agents differ from chatbots, the reason–act–observe loop, and where agentic AI fits into DevOps. Next, you’ll learn to actually communicate with these models through effective prompting.