What Agentic AI Is

Agentic AI is software in which a language model decides what to do next, does it, looks at what happened, and repeats until a goal is met. Three words to learn first:

• A language model (LLM) is a program that reads text and writes text. On its own it can only write.
• An AI agent is a language model placed in a loop and given tools: functions it can ask your program to run, such as 'look up this order'.
• Agentic describes how much of the deciding the model does. A system is more agentic the more it chooses its own steps.

The shift is from software that answers to software that finishes work:

• A question-answering system tells a customer what the refund policy says.
• An agentic system finds the customer's order, checks it against the policy, issues the refund and confirms it.

That is far more useful, and it raises the stakes: a wrong answer is a bad sentence, but a wrong action is real money moved or a real file deleted.

Every agent runs the same loop:

• Observe: read the goal and everything that has happened so far.
• Reason: work out what is known and what is still missing.
• Decide: choose one next step, either an action or 'I am finished'.
• Act: your program carries out the action.
• Observe again: the result of the action is added to what the model reads next.

The loop ends when the model says it is finished, or when a limit you set is reached.

The loop is what lets software handle a task whose steps are not known beforehand.

• The agent cannot know which refund rule applies until it has seen the order.
• It cannot know whether the refund worked until it has tried.
• Each result shapes the next step, which a fixed script cannot do.

Four things are often confused. Each adds one ability to the one before:

• An LLM writes text from the text it is given. It knows only what it learned in training.
• A chatbot is an LLM with the conversation so far resent each time, so it can hold a dialogue.
• A RAG system (retrieval-augmented generation) first searches your documents, then gives the model what it found, so the answer is grounded in your data.
• An agent chooses which tools to use, in what order, for how many steps, and can change things as well as read them.

Knowing the difference stops you over-building.

• If the user needs an answer from your documents, RAG is enough and costs one model call.
• If the user needs something done, or the answer needs several look-ups that depend on each other, you need an agent.
• An agent can use RAG as one of its tools. They are not rivals.

Three older ways of getting multi-step work done, and how an agent differs:

• Traditional software: a programmer writes every rule. Same input, same output, every time.
• Automation (scripts, robotic process automation, 'if this then that'): fixed steps triggered by an event. No judgement.
• A workflow with a model in it: your code fixes the steps and their order; the model fills in each one (classify this, summarise that).
• An agent: the model chooses the steps and their order while it works.

They trade predictability for flexibility:

• Rules and workflows are cheap, fast, testable and do the same thing every time.
• An agent copes with cases nobody wrote a rule for, and is harder to predict, test and budget.

If you can draw the steps as a flow chart before you start, build the flow chart. An agent earns its place only when the path depends on what is found on the way.

A system is agentic to the degree that it has these five properties:

• Goal-directed: it is given an outcome to reach, not a list of steps.
• Autonomous choice: the model picks the next step itself.
• Tool use: it can read from and act on systems outside the model.
• Feedback: it sees the result of each action and adjusts.
• Persistence: it keeps going over many steps, and remembers what it has done.

This list is a practical test.

• Ask of any system: who decides the next step, and can that decision depend on what the last step found? If the answer is 'the model' and 'yes', it is agentic.
• It also tells you what to build: each property maps to a part covered later (goals and prompts, the loop, tools, observations, memory and state).

Autonomy is how much an agent does without a person. Five levels, from least to most:

• Level 0, assist: the model drafts; a person does everything.
• Level 1, suggest: the agent proposes an action; a person carries it out.
• Level 2, act with approval: the agent prepares the action; a person clicks approve.
• Level 3, act then report: the agent acts; a person reviews afterwards.
• Level 4, act alone: the agent acts within fixed limits; people see only the exceptions.

The right level depends on two things: what a mistake costs, and whether it can be undone.

• Looking up an order is free to get wrong: level 4.
• A ₹25 refund is cheap and reversible: level 3 or 4, with a cap.
• Closing an account cannot be undone: level 2.
• The same agent sits at different levels for different actions.

Where agentic systems are in real use today:

• Customer support: resolve refunds, bookings and account changes, not only answer questions.
• Coding: read a codebase, change files, run the tests, fix what failed.
• Research: search many sources, read them, cross-check claims, write a cited report.
• Data analysis: write a query, run it, look at the result, chart it, explain it.
• Operations: triage alerts, gather logs, propose or apply a fix.
• Personal tasks: plan a trip, manage a calendar, fill in forms across websites.

The successful uses share a shape, and that shape is your guide for spotting new ones.

• The task takes several steps that depend on each other.
• There are tools that give real information and real effect.
• Success can be checked: the tests pass, the refund appears, the sources support the claim.
• A mistake can be caught or undone.

Use an agent only when all of these are true:

• the task needs several steps that depend on each other;
• the path cannot be written down in advance;
• there are tools that give it real information or effect;
• there is a way to check whether it succeeded;
• mistakes are tolerable or reversible, or a person approves the risky ones.

If any is false, use something simpler: one model call, a RAG system, or a fixed workflow.

An agent costs more than a single call in every way:

• many model calls, so more money and more waiting;
• more ways to fail, and errors that build on each other;
• harder testing, because the path varies from run to run.

That price is worth paying for open-ended work and wasted on fixed work.

One example carries this whole course. Kirana Kart is a made-up grocery delivery app. It wants an agent that resolves support requests. The agent can:

• look up a customer's orders;
• read the policies on refunds, late delivery and cancellations;
• issue a refund, within limits;
• reschedule or cancel a delivery;
• hand over to a human with a summary.

It is a good teaching example because it contains every hard part of agent design:

• it reads private data, so it needs permission checks;
• it spends money, so it needs limits and approval;
• some actions cannot be undone, so retries must be safe;
• customers will try to talk it into things, so it needs guardrails;
• it must know when to stop and call a person.

The questions interviewers ask about the basics of Agentic AI, from the first screening call to the senior round. Cover the answer, say yours aloud, then compare.

Reading an idea and explaining it are different skills.

• Each answer below is the two or three sentences an interviewer is listening for.
• The reasoning behind each one is in the cards above. If an answer surprises you, go back to that card.

A short build that uses this module's ideas. Write it yourself before looking anything up; the checks at the end tell you whether it works.

An idea you have only read fades in a week.

• Building it once, even in fifty lines, is what makes it yours.
• Interviewers can tell the difference between someone who has read about a loop and someone who has debugged one.