Introduction to agentic AI: from chatbots to autonomous agents

Welcome to Module 6. In Module 5, you built a RAG system that retrieved wellness content for users. That system was reactive: it answered questions but never took independent action. Agentic AI changes this. Instead of waiting for a prompt, an agent perceives its environment, sets goals, and acts over multiple steps. In this lesson, you will transition from building chatbots to designing autonomous agents that execute complex workflows, like curating a personalised mental health plan or coordinating a wellness subscription box shipment.

What is agentic AI?

Agentic AI refers to systems that can pursue goals autonomously. Unlike a simple question-answer bot, an agent has three properties: it perceives (reads user data or tool outputs), it decides (plans a sequence), and it acts (calls APIs, modifies databases). For example, a chatbot for 'Calm Kids Bedtime Stories' only fetches a story. An agentic version would analyse the child's sleep history, select a story, schedule a reading time, and send a reminder — all without human intervention.

In the industry, agentic AI is measured by its autonomy level. Level 0 is a bot that reacts. Level 1 is a task-specific agent (like an email sorter). Level 2 is a goal-driven agent that decomposes a high-level request. Level 3 is a self-learning agent. This course focuses on Level 1 and Level 2, which are production-ready today. For your store, Sukhbeer's Creations, a Level 2 agent could monitor customer stress scores from the 'Stress Reset Toolkit' and automatically suggest a relevant 'Focus & Deep Work Sessions v2' product if scores drop below a threshold.

Try this: open your terminal and create a file agent_definition.py. Write a Python class WellnessAgent that stores a goal and has a perceive method that prints 'Reading customer pulse...' and an act method that prints 'Recommending product X'. This is a skeleton. Later you will flesh it out with real logic.

class WellnessAgent:
    def __init__(self, goal):
        self.goal = goal
    def perceive(self, data):
        print(f'Reading customer data: {data}')
    def act(self, action):
        print(f'Executing action: {action}')

From chatbots to autonomous agents: the evolution

Chatbots emerged as pattern-matchers (ELIZA, 1966). Modern chatbots use LLMs to generate fluent responses, but they are still stateless and passive. The shift to agents happened when developers gave LLMs tool use (calling APIs), memory (storing conversation history), and planning (chain-of-thought reasoning). In 2023, frameworks like LangChain and AutoGPT demonstrated that an LLM could break a goal like 'Book a flight' into sub-tasks: search flights, compare prices, reserve seats. Each sub-task uses a different tool.

In your wellness business, consider the 'Monthly Wellness Box India'. A chatbot could tell a customer what is in the box. An agent would: (1) check the customer's past purchases, (2) review their preference profile (e.g., prefers herbal teas over incense), (3) customise the next box, and (4) place the order. This requires multiple API calls and a persistent memory of user preferences.

The key architectural difference is the control flow. In a chatbot, the user drives the conversation. In an agent, the system drives itself. The agent maintains an internal state (a 'scratchpad') that records its plan, steps taken, and observations. It loops until the goal is met or a limit is reached.

Exercise: Draw a sequence diagram for an agent that handles a 'Sukhbee Inner Circle Membership' renewal. The agent must: fetch membership expiry date, send a reminder email, process payment, update membership status, and confirm. Show which steps are autonomous and which require user approval.

Core components: planning, memory, tool use

Every agent architecture rests on three pillars:

Planning: The agent decomposes a complex goal into steps. Techniques include chain-of-thought, ReAct (Reason + Act), and tree-of-thought. In practice, you prompt the LLM to 'Think step by step. For each step, choose a tool from your available tools and call it.'
Memory: The agent needs both short-term memory (the current conversation) and long-term memory (user history, past actions). You can store memory in a vector database (like ChromaDB) or a key-value store (Redis). For your store, long-term memory remembers that a customer bought 'Complete Wellness Bundle India' last month, so the agent does not recommend it again.
Tool use: Tools are functions the agent can call. Examples: search product catalog, send email, update database, query weather API. Each tool has a name, description, and parameters. The LLM decides which tool to invoke based on the description.

In your project, you will build an agent that uses three tools: product_search(query), customer_profile(customer_id), and send_email(recipient, subject, body). For instance, the agent's goal could be 'Increase retention for customers who haven't purchased in 90 days.' The agent plans: (1) get list of inactive customers via database query (a tool), (2) for each, fetch their profile, (3) generate a personalised offer, (4) send an email. This is a single agent. In later lessons, you will create multi-agent teams where one agent handles outreach and another handles fulfilment.

Safety disclaimer: Always limit the tools an agent can call to prevent unintended actions. If your agent has an 'update order status' tool, ensure it only runs after user confirmation. In production, use a human-in-the-loop for irreversible operations.

Multi-agent architectures: a preview

A single agent can get stuck or overwhelmed. Multi-agent systems split responsibilities. For example, a 'Supervisor Agent' receives a request and assigns sub-tasks to specialised agents: a 'Research Agent' gathers information, a 'Recommendation Agent' analyses trends, a 'Communication Agent' drafts replies. This mirrors a team of employees. In wellness, you could have an 'Assessment Agent' that runs a stress quiz, an 'Action Agent' that selects exercises from 'Relief Program', and a 'Follow-up Agent' that checks progress after a week.

The challenge is coordination. Agents must share a common memory and pass messages. Frameworks like CrewAI and AutoGen provide orchestration patterns. In this module, you will implement both sequential (chain) and hierarchical (supervisor + workers) multi-agent patterns.

Hands-on: Install crewai with pip install crewai. Then define two agents in Python: StoryTeller and ActivityMaker. The StoryTeller generates a bedtime story for kids. The ActivityMaker provides a follow-up craft project. Use a sequential process where the StoryTeller's output is passed to the ActivityMaker. Run it. This is a minimal multi-agent system that could sell 'Calm Kids Bedtime Stories' along with a related physical product like 'Classic Teddy Bear'.

from crewai import Agent, Task, Crew

storyteller = Agent(
    role='Storyteller',
    goal='Create a short calming bedtime story.',
    backstory='You write soothing stories for children.',
    tools=[]
)
activity_maker = Agent(
    role='Activity Maker',
    goal='Design a simple craft tied to the story.',
    backstory='You make creative activities for kids.',
    tools=[]
)
task1 = Task(description='Write a 3-paragraph story about a teddy bear.', agent=storyteller)
task2 = Task(description='Create a paper craft activity based on the story.', agent=activity_maker)
crew = Crew(agents=[storyteller, activity_maker], tasks=[task1, task2], process='sequential')
result = crew.kickoff()
print(result)

Summary and next lesson

You have learned the core difference between reactive chatbots and autonomous agents. Agentic AI uses planning, memory, and tools to pursue goals independently. You built a skeleton agent and saw a preview of multi-agent systems. In the next lesson, you will implement tool use and memory with LangGraph, turning your skeleton into a production-ready agent for your store.