The 5 Layers of Agentic AI, Explained by Building the Same App Five Times

Mariana Antaya walks through the five layers of agentic AI by building the same application at each level: a stock news portfolio tool. Each layer adds a specific capability, and the progression makes clear what "agentic" actually means in practice. The video pairs talking-head explanation with live code in VS Code, showing Python implementations at every step.

Layer 1: A Single LLM Call

The simplest version is a direct prompt to a language model. You ask "what's the latest news on NVIDIA?" and the model responds with whatever it has in its training data. The result is vague and probably outdated because the model has no access to real-time information. This is where most people start when they first interact with an LLM, and it is useful for understanding the baseline before adding any tooling.

Layer 2: RAG (Retrieval-Augmented Generation)

The second layer introduces real data through an external API. Instead of relying on the model's training data, the system fetches current stock news from a live source and passes that context into the prompt. The output is now grounded in actual, recent information. This is the layer where most chatbot-style products operate today, and it solves the freshness problem that makes Layer 1 unreliable for anything time-sensitive.

Layer 3: True Agent Behavior

Layer three is where the system becomes an agent that reads your portfolio and decides what to look up. Rather than you telling it which stock to research, the agent inspects the portfolio file, identifies which stocks you hold, and then fetches news for each one. The key difference here is autonomy: the agent is making decisions about what data to retrieve based on context it discovers on its own. Antaya shows the code for this in VS Code, with the agent reading a portfolio file and looping through the tickers.

Layer 4: Multi-Agent Systems

At this layer, multiple specialized agents each handle a single task. One agent fetches the stock tickers from your portfolio. A second agent summarizes the news for each stock. A third agent runs sentiment analysis and returns whether the outlook is positive, negative, or neutral. The code on screen shows distinct agent functions coordinating in sequence, with each one doing exactly one job. This decomposition makes each agent simpler to build, test, and debug compared to a single monolithic agent trying to do everything.

Layer 5: Observability and Retries

The final layer adds the production-readiness features that most tutorials skip. If an API call fails, the system retries or falls back to an alternative method. Antaya frames this as "the very beginning of production AI," and she is right. Observability (logging, tracing, monitoring) and resilient error handling are what separate a demo from software you can actually run for users. This layer does not change the core logic but wraps it in the reliability guarantees that real deployments require.

Key Takeaways

• Layer 1 (Single LLM call) gives you a quick answer, but it is limited to the model's training data and goes stale fast.
• Layer 2 (RAG) grounds the model in real-time data through API calls, solving the freshness problem.
• Layer 3 (Agent) introduces autonomy by letting the system decide what to look up based on your actual portfolio.
• Layer 4 (Multi-agent) decomposes the work into specialized agents, each handling one concern like fetching, summarizing, or sentiment analysis.
• Layer 5 (Observability and retries) is the production layer where error handling, fallbacks, and monitoring make the system reliable enough to ship.
• Most people building AI tools today are operating at Layer 1 or Layer 2. The jump to Layer 3 is where the real leverage shows up.

Resources

• OpenAI Function Calling Documentation for building agents that use tools
• LangChain Multi-Agent Guide for orchestrating multiple specialized agents
• Mariana Antaya on TikTok for more AI engineering breakdowns