TL;DR: Agentic AI is a meaningful shift toward systems that reason, remember, plan, and act. In this episode, hosts Vishnu Vettrivel and Alex Thomas unpack what it really means to build AI agents with memory and decision-making capabilities. From the CoALA framework to Minecraft agents and digital assistants, this is a deep dive into the future of AI autonomy.

The term “agentic AI” has gained momentum recently, but it is more than a buzzword. As AI systems grow more capable, the bar is rising. Users are beginning to expect more than an intelligent conversation. They want systems that can reason through problems, plan their next move, and take meaningful action autonomously.

In this episode of Gradient Descent, Vishnu Vettrivel and Alex Thomas unpack what Agentic AI really means. To anchor the conversation, the hosts turn to a key resource: the Cognitive Architectures for Language Agents, the CoALA framework. The paper provides a structured, modular approach to designing intelligent, action-oriented AI agents.

The hosts explore the components that distinguish true agents from chatbots: memory, decision-making, and the ability to act in the world. If you’ve heard the hype around agentic AI and want to understand what’s actually under the hood, this episode offers a grounded, thoughtful starting point.

Agentic AI: The Shift from Simple Bots to Capable Agents

Agentic AI is generating so much buzz because it represents a fundamental shift in what AI systems can do and how they do it. Unlike traditional chatbots that merely respond to user input with pre-trained text completions, agentic AI systems reason, plan, remember, and act autonomously. That shift from static interaction to dynamic, task-oriented behavior is redefining what we expect from intelligent systems.

Most chatbots today are excellent conversationalists. They respond to prompts, generate coherent answers, and even hold multi-turn dialogue. But they don’t retain long-term memory, plan ahead, or take initiative.

Agentic AI changes that. These systems are built to behave less like scripted responders and more like autonomous assistants. As Vishnu explains: “It’s the difference between a chatbot that suggests vacation destinations and an agent that books your flights, remembers your seating preferences, applies loyalty points, and justifies its choices based on your past preferences.”

Where It All Began: From Symbolic Systems to Modern Agents

Agentic AI may sound like a cutting-edge development, but the ideas behind it have deep roots. Long before large language models entered the picture, AI researchers were already exploring how machines might think, plan, and act in the world.

The Limits of Symbolic Design

Cognitive architectures like Soar and ACT-R set the stage in the 1980s. These early systems were designed to mirror human reasoning using symbolic representations and rule-based logic. They relied on production systems (a system composed of if-then rules) that allowed an agent to respond to its environment in structured, step-by-step ways.

Soar, for example, could store experiences, manage goals, and break complex problems into smaller chunks. It even supported forms of memory that resemble the ones used in modern agents: episodic memory for past events, procedural knowledge for tasks, and working memory for in-the-moment reasoning. While limited by the technology of the time, these systems laid the intellectual foundation for what we now recognize as agentic behavior.

However, the challenge was scale. Symbolic systems required teams of experts to handcraft every rule. They struggled to generalize beyond tightly defined environments. As AI ambitions grew, so did the need for systems that could learn, adapt, and make decisions in messier, less predictable settings.

This is where large language models have changed the equation.

The Rise of Probabilistic Agents

Unlike their symbolic predecessors, LLMs operate probabilistically. They don’t rely on manually coded rules. Instead, they learn from massive datasets, identify patterns, and generate context-aware responses on the fly.

In doing so, they function like a new kind of production system, one that’s flexible, scalable, and capable of adapting to uncertainty. As Vishnu notes in the episode, “Previously, agentic systems were built deterministically. Designers had to code in rules, flows, and conditions explicitly. Now, LLMs can operate probabilistically, dynamically choosing actions based on context. They can learn how to use APIs and associate actions through well-described prompts.”

In many ways, LLMs are breathing new life into old ideas. They’ve taken the core vision of cognitive architectures, helped create intelligent agents that plan, remember, and act, and rebuilt them with the statistical power and contextual depth that today’s AI can offer.

The result is a new class of systems that are more human-like in processing information, adapting to change, and pursuing goals over time. While the tools have evolved, the underlying ambition remains the same: to build machines that don’t just respond but reason.

Inside the Mind of an Agent: The CoALA Framework

What sets an agentic system apart is not its ability to generate responses or interact with APIs. The defining trait lies in how it reasons, remembers, and decides what to do next. 

The CoALA framework provides a practical and modular foundation for building agents that do more than just react. It is centered around three critical components: Memory, action space, and decision-making. These elements are the cognitive machinery that enables an agent to behave intelligently, adapt in real time, and improve with experience.

Memory: Learning Through Experience

Memory is essential for an agent to improve over time. CoALA organizes memory into three categories. 

• Semantic memory stores factual knowledge. These are general truths, such as “Bogotá is the capital of Colombia.” It is the agent’s stable reference point for universally known information.

• Episodic memory captures personal history. This could include past conversations, previous decisions, or outcomes from earlier tasks. As Vishnu notes, even subjective experiences can be useful. Suppose an agent recalls that a previous interaction with Alex went poorly after mentioning DC Comics. In that case, it might avoid the topic next time, regardless of whether the memory is factual or simply behavioral.

• Procedural memory is the agent’s internal record of how to perform actions. This includes knowing how to interact with APIs, follow workflows, or complete multi-step tasks. It is the equivalent of muscle memory in humans.

As Vishnu points out, "agents should not hold onto every detail." Like people, they benefit from prioritizing the most relevant patterns, rather than recalling isolated events.

Action Space: Adapting to the Situation

In the past, AI systems responded based on predefined instructions. Modern agents take a more flexible approach. Rather than depending on hardcoded actions, they infer possible steps by interpreting language and context. This makes it easier for them to function in unfamiliar environments.

The CoALA framework highlights this flexibility with a Minecraft example. The agent isn’t explicitly taught how to fight a zombie. Instead, it reasons that it must first construct a weapon and then engage in the task, planning each sub-action as needed. 

Decision-Making: Considering Alternatives

Effective agents explore different paths, weigh options, and adjust as they go. This type of reasoning, often called Tree-of-Thought, allows agents to test possible solutions before settling on one. It reflects how people make decisions by comparing, revising, and learning as they proceed.

A Modular Approach to Design

One of CoALA's strengths is its modular structure. Each agent component, whether memory, planning, or action, is designed to operate independently. This allows developers to update parts of the system without reworking everything from the ground up. Vishnu explains: “Understanding the agent’s process—observation, planning, execution, memory update—helps developers modularize and organize their code effectively. It’s a very actionable framework. It bridges the gap from conceptual design to real-world implementation.”

The Agentic Loop: A Framework for Adaptive Behavior

The agentic loop describes how intelligent systems observe, plan, act, and reflect to improve over time. Alex explains, “This is how an agent learns, adapts, and becomes increasingly useful over time. They develop preferences, adjust to feedback, and operate with increasing autonomy.”

Observation: Recognizing Internal and External Signals

The loop begins with observation. Agents gather input from users or the environment, but they can also monitor their own performance. For instance, a missed calendar reminder might prompt an agent to reconsider its notification approach. Observation initiates the cycle by helping the agent identify what requires attention.

Planning: Reasoning Toward a Goal

Agents use memory to evaluate possible actions in the planning phase. This step involves prioritizing goals, simulating outcomes, and preparing for complex tasks. Planning is not just about finding the next step but organizing decisions in line with long-term objectives.

Execution: Acting with Purpose

Execution turns decisions into action. This might involve sending a message, retrieving data, or triggering an external process. Some actions are visible, while others operate behind the scenes. What matters is that the system carries out a plan based on reasoning, not a scripted response.

Reflection: Learning from Outcomes

After acting, the agent reflects on the result. It evaluates what worked, what didn’t, and what should change. This phase supports learning. Updating memory and refining strategies allows agents to avoid repeating mistakes and respond more effectively in the future.

Through this loop, agentic systems develop continuity, becoming more responsive and context-aware over time. The process is foundational to how these systems grow in both capability and reliability.

Case Studies: Agents in the Wild

While much of the episode focuses on frameworks and design principles, Vishnu and Alex explore how agentic systems are already operating beyond the lab. These real-world examples help illustrate how agentic AI is applied across different domains. 

Agents in Physical Environments

In robotics, one of the key challenges is translating natural language commands into real-world actions. Systems influenced by approaches like SayCan address this by combining language understanding with action planning. The agent must interpret a high-level goal, evaluate available tools, and break the task into smaller steps that it can carry out safely and efficiently.

Agents That Combine Reasoning and Action

The ReAct framework is directly mentioned during the episode as an example of agentic behavior in digital settings. Rather than separating thought from execution, ReAct blends both into a continuous loop. The agent reasons through intermediate steps, interacts with tools, and revisits its strategy based on feedback from the environment.

This approach is particularly effective in tasks that involve multiple layers of decision-making, such as answering questions, navigating user interfaces, or coordinating digital workflows. The agent does not simply generate a response and move on. It evaluates what it knows, identifies what it needs to discover, and takes deliberate steps toward completing the task.

Why Agentic AI Matters: From Useful Systems to Capable Partners

Agentic AI is often discussed in the context of Artificial General Intelligence. These systems can reason, adapt, and complete tasks across different domains, which makes the comparison tempting. However, as Alex notes, reality is more measured. “We believe we’re closer to AGI than we actually are. The sheer breadth of human faculties is astounding.”

Agentic AI is a new class of broadly capable systems that support a range of functions while improving through interaction and feedback. While they don’t showcase general intelligence, they are meaningfully more adaptive and helpful than previous tools.

Looking Ahead: Access, Influence, and the Need for Guardrails

With growing capability comes a new set of concerns. Vishnu points out that access to the most advanced agents will not be evenly distributed. “People with more resources will be able to build more capable, better-trained agents. It becomes almost like building characters in a game—those with the best gear win.”

This introduces the risk of uneven benefits. Better infrastructure leads to more capable systems, widening the gap between users and organizations with access to state-of-the-art AI and those without it.

Alongside access, influence becomes harder to ignore. Personalized agents can guide decisions, surface content, and shape user preferences over time. That kind of influence may be subtle, but it raises questions about alignment, transparency, and control. “It even reminds me of shows like Caprica... and certainly echoes Black Mirror.”

These aren’t far-off scenarios. They reflect the direction in which technology is already moving. As these systems become more embedded in daily life, their impact will depend on how intentionally they are designed.

Final Thoughts: Not Hype—A Blueprint

This episode clarifies one thing: agentic AI isn’t marketing fluff. It’s a real and practical architectural shift toward systems that observe, learn, and act over time.

The CoALA framework gives us a blueprint, and the current tooling makes it possible. What happens next will depend on how thoughtfully we build and how responsibly we guide this new generation of AI.

Stay curious. Stay critical. And if you haven’t yet, explore the CoALA paper, experiment with LangGraph, and let us know how you’re building agentic systems of your own.

You can listen to all episodes of Gradient Descent on YouTube or subscribe to our official podcast newsletter on LinkedIn. We share episode updates, behind-the-scenes insights, recommended readings, and curated research notes straight to your inbox.

Got thoughts or questions? Email us at oksana@wisecube.ai.