Ask a chatbot "book me the cheapest flight to Bangalore tomorrow" and it explains, very politely, how flight booking works. Ask an agent and it searches, compares, books, and sends you the PNR. Same model underneath — completely different system around it. Agentic AI is the loudest phrase in the industry right now, it's in every AI job description, and interviewers are actively separating people who understand it from people who can say the word. This free course puts you firmly in the first group.
What is an AI agent?
An AI agent is an LLM given three things: a goal, a set of tools it can call, and a loop in which it decides what to do next based on what it just observed. A chatbot produces a response. An agent pursues an outcome — planning, acting, reading results, and adjusting until the goal is met or it gives up honestly.
The distinction that matters in interviews isn't model size or tool count. It's this: who decides the next step — your code, or the model? Your code deciding is a workflow. The model deciding is an agent.
The one idea: everything is the loop
Every agent framework, pattern and buzzword in this course is a variation on four lines:
while not done and steps < MAX_STEPS:
decision = model.decide(goal, history) # think
result = run_tool(decision) # act
history.append(result) # observeThat's it. ReAct adds a written thought before each action. LangGraph draws the loop as a graph with persistent state. Multi-agent systems run several loops with a coordinator. Guardrails constrain what run_tool is allowed to do. Keep this skeleton in your head and nothing later in the course will feel like magic.
Your first agent — right now
A real (tiny) agent: a goal, one tool, a bounded loop.
TOOLS = {"get_weather": lambda city: f"{city}: 31C, clear"}
messages = [{"role": "user", "content": "Should I carry an umbrella in Pune?"}]
for step in range(4): # bounded — always
reply = client.chat.completions.create(
model="gpt-4o-mini", messages=messages, tools=TOOL_SCHEMAS,
).choices[0].message
messages.append(reply)
if not reply.tool_calls: # no tool needed -> final answer
print(reply.content)
break
for call in reply.tool_calls: # act, then observe
result = TOOLS[call.function.name](**json.loads(call.function.arguments))
messages.append({"role": "tool", "tool_call_id": call.id,
"content": result})Result
Pune is 31°C and clear right now — no umbrella needed today.
Two model calls: one to decide the tool, one to phrase the answer from its result.
Twenty lines, and it genuinely qualifies as an agent: it decided to use a tool, read the result, and answered from it. Everything else in this course — memory, planning, multi-agent teams, approval gates, evaluation — is engineering built around this shape.
Why learn agents (the honest version)
One: it's the hiring trend of 2026 — job descriptions ask for LangChain, LangGraph, CrewAI and "agentic workflows" by name, and interview guides for LangGraph alone run to hundreds of questions. Two: it's the natural next step after RAG in real projects — once a bot can answer, the request becomes "can it also do things?" Three: the judgment it teaches — when NOT to use an agent, how to bound autonomy, how to test non-deterministic systems — is exactly what separates senior candidates in AI interviews.
How this course works
Every lesson starts from a real situation, builds intuition, names the technical concept, and shows runnable Python plus diagrams. Each ends with a Practice Zone — MCQs and hands-on tasks with the companies where each pattern has been asked shown under the question.
Prerequisites: you should know what an LLM is and how function calling works. If not, read the Generative AI course first — particularly lesson 8 on APIs and tool calling. Lessons here also assume the retrieval ideas from the RAG course, though we recap what matters.
Course roadmap — 12 lessons
| # | Lesson | What you'll be able to answer |
|---|---|---|
| 1 | What Are AI Agents? | Chatbot vs workflow vs agent — and when NOT to build one |
| 2 | Tool Calling | How an LLM takes real actions — and where safety lives |
| 3 | Agent Architectures | ReAct, Plan-and-Execute, Reflection — and step limits |
| 4 | LangChain Basics | Chains, LCEL, parsers, memory — and framework trade-offs |
| 5 | LangGraph | State, nodes, conditional edges, checkpoints, human-in-the-loop |
| 6 | Memory & Context | Short vs long-term memory, compaction, context engineering |
| 7 | Multi-Agent Systems | Supervisor pattern, hand-offs, and when one agent is better |
| 8 | Frameworks Compared | LangGraph vs CrewAI vs AutoGen vs raw loop vs MCP |
| 9 | Evaluation & Tracing | Trajectory evaluation, mocked tools, agent metrics |
| 10 | Safety & HITL | Autonomy ladders, least privilege, indirect prompt injection |
| 11 | Agents + RAG + MCP | How the pieces fit — and which layer owns which problem |
| 12 | Agent System Design | The full design-round answer, start to finish |
Company-wise agent PYQs
After the lessons comes a set of company-wise agentic AI interview questions — the patterns reported from TCS, Infosys, Accenture, Amazon, Microsoft and Google — in attempt-then-reveal format, each linked to the lesson behind it.
How to study this course
Read 1–3 in order; they build the mental model everything else uses. Then 5, 9 and 10 are the lessons that show up most in interviews (LangGraph, evaluation, safety). Build one small agent yourself — two tools, a bounded loop — before your interview. One sentence about a real agent you debugged outweighs a whole vocabulary of framework names.
FAQ
Do I need to know LangChain to learn agents?
No — and this course deliberately teaches the raw loop first. Frameworks are covered (lessons 4, 5, 8) as what they are: operational leverage for state, checkpoints, approvals and tracing. Interviewers ask what happens inside the loop, not for API recall.
Are agents actually used in production, or is it hype?
Both are true. Real production agents exist in support, coding and research — narrow scope, bounded loops, human approval for irreversible actions. The hype is in claims of broad autonomy. This course teaches the version that ships.
What's the difference between agentic AI and AGI?
Everything. Agentic AI is an engineering pattern — an LLM in a loop with tools, bounded by your code. It has no general understanding and no goals of its own beyond the one you hand it in a prompt.
What should I learn after this course?
Model Context Protocol — the emerging standard for how agents connect to tools and data, and the plumbing layer under most of what you'll build next.
Ready? Start here — Lesson 1: What Are AI Agents? →