Podcast
GenAI Level UP
Hosted by GenAI Level UP · EN
[AI Generated Podcast]
Learn and Level up your Gen AI expertise from AI. Everyone can listen and learn AI any time, any where.
Whether you're just starting or looking to dive deep, this series covers everything from Level 1 to 10 – from foundational concepts like neural networks to advanced topics like multimodal models and ethical AI. Each level is packed with expert insights, actionable takeaways, and engaging discussions that make learning AI accessible and inspiring.
🔊 Stay tuned as we launch this transformative learning adventure – one podcast at a time. Let’s level up together! 💡✨
20episodes
Episodes
Newest firstAll episodes
Master the New Physics of AI with Context Graphs & GraphRAG
Feb 100:17:36Tap to summarizeStop trying to find the "magic words" to hack your LLM. The era of the Prompt Engineer—tweaking adjectives and hoping for the best—is officially over. We are entering the age of the Context Engineer, a discipline not about "cooking the meal," but about "stocking the pantry" with architected, structured intelligence.In this episode of GenAI Level UP, we dismantle the outdated notion of linear prompting and reveal the geometric reality of how Large Language Models actually reason. You will discover why "Context Graphs" are displacing static Knowledge Graphs, how to lower the "energy barrier" for complex AI reasoning, and exactly which architectures—from Graph-R1 to LogicRAG—are rewriting the rules of retrieval.If you are building AI agents or enterprise systems, this is your blueprint for moving from hallucination-prone chatbots to reasoning engines that deliver verifiable truth.In this episode, you’ll discover:(01:15) The "Culinary" Shift: Why we are moving from the chef (prompting) to the pantry (context engineering) and why this architectural change is non-negotiable for future AI development.(03:55) The Physics of In-Context Learning: We unpack the groundbreaking "Energy Minimization Model." Learn how structuring data as graphs literally lowers the cognitive friction for LLMs, allowing them to "see" relationships rather than guess them.(07:20) Warehouse vs. Workspace: The critical distinction between a static Knowledge Graph (the Source of Truth) and a dynamic Context Graph (the Source of Relevance)—and why your agent needs the latter to function.(10:45) The GraphRAG Ecosystem: A deep dive into the three new titans of retrieval:The Explorer (Graph-R1): Using reinforcement learning to navigate hypergraphs.The Planner (LogicRAG): "Just-in-Time" graph construction that prunes context to keep signal-to-noise ratios high.The Sprinter (SubGraphRAG): How simple MLPs can score relevance faster than heavy transformers.(15:30) The "Compliance Gate" & Medical AI: Real-world case studies in Law and Medicine where "Context Engineering" acts as a semantic decoder, turning raw ECG signals into language and complex regulations into binary logic.(19:15) The Future is the LCM: Why the "Large Context Model" will soon turn context from a temporary buffer into a persistent "Digital Hippocampus."Join us to level up your understanding of the structural elegance that will define the next generation of AI.
Transcribe →
Context Graph
Jan 2500:19:35Tap to summarizeStop feeding your AI static facts in a dynamic world.Most RAG systems and Knowledge Graphs rely on a fundamental unit called the "Triple" (Subject, Verb, Object). It’s efficient, but it’s brittle. It tells you Steve Jobs is the Chairman of Apple, but fails to tell you when. It tells you where a diplomat works, but assumes that’s where they hold citizenship. This lack of nuance is the root cause of "False Reasoning"—the logic traps that cause models to hallucinate confidently.In this episode, we deconstruct the breakthrough paper "Context Graph" to reveal a paradigm shift in how we structure AI memory. We explain why moving from "Triples" to "Quadruples" (adding Context) allows LLMs to stop guessing and start analyzing.We break down the CGR3 Methodology (Context Graph Reasoning)—a three-step process that bridges the gap between structured databases and messy reality, yielding a verified 20% jump in accuracy over standard prompting. If you are building agents that need to distinguish between truth and outdated data, this is the architectural upgrade you’ve been waiting for.In this episode, you’ll discover:(00:00) The "Pasta" Problem: Why an AI can know a restaurant’s star rating but still ruin your quiet business meeting (the failure of context-blind data).(02:06) The Tyranny of the Triple: Why the industry standard for Knowledge Graphs (Subject-Relation-Object) creates "False Reasoning" loops.(05:05) The Logic Trap: How over-simplified database rules confuse diplomatic service with citizenship—and how to fix it.(06:15) Enter the Quadruple: Moving from Knowledge Graphs to Context Graphs by adding the fourth critical dimension: Time, Location, and Provenance.(08:25) The CGR3 Framework: A deep dive into the 3-step engine: Context-Aware Retrieval, Temporal Ranking, and the Reasoning Loop.(11:30) The 20% Leap: analyzing the benchmark data that shows how Context Graphs beat standard ChatGPT prompting (78% vs 57% accuracy).(12:15) Solving the "Long Tail": How this method helps AI hallucinate less on obscure facts by "reading the fine print" rather than memorizing headers.
Transcribe →
Nested Learning: The Illusion of Deep Learning Architectures
Nov 1400:13:12Tap to summarizeWhy do today's most powerful Large Language Models feel... frozen in time? Despite their vast knowledge, they suffer from a fundamental flaw: a form of digital amnesia that prevents them from truly learning after deployment. We’ve hit a wall where simply stacking more layers isn't the answer.This episode unpacks a radical new paradigm from Google Research called "Nested Learning," which argues that the path forward isn't architectural depth, but temporal depth.Inspired by the human brain's multi-speed memory consolidation, Nested Learning reframes an AI model not as a simple stack, but as an integrated system of learning modules, each operating on its own clock. It's a design principle that could finally allow models to continually self-improve without the catastrophic forgetting that plagues current systems.This isn't just theory. We explore how this approach recasts everything from optimizers to attention mechanisms as nested memory systems and dive into HOPE, a new architecture built on these principles that's already outperforming Transformers. Stop thinking in layers. Start thinking in levels. This is how we build AI that never stops learning.In this episode, you will discover:(00:13) The Core Problem: Why LLMs Suffer from "Anterograde Amnesia"(02:53) The Brain's Blueprint: How Multi-Speed Memory Consolidation Solves Forgetting(03:49) A New Paradigm: Deconstructing Nested Learning and Associative Memory(04:54) Your Optimizer is a Memory Module: Rethinking the Fundamentals of Training(08:00) The "Artificial Sleep Cycle": How Exclusive Gradient Flow Protects Knowledge(08:30) From Theory to Reality: The HOPE & Continuum Memory System (CMS) Architecture(10:12) The Next Frontier: Moving from Architectural Depth to True Temporal Depth
Transcribe →
Memento: Fine-tuning LLM Agents without Fine-tuning LLMs
Nov 100:18:54Tap to summarizeWhat if you could build AI agents that get smarter with every task, learning from successes and failures in real-time—without the astronomical cost and complexity of constant fine-tuning? This isn't a distant dream; it's a new paradigm that could fundamentally change how we develop intelligent systems.The current approach to AI adaptation is broken. We're trapped between rigid, hard-coded agents that can't evolve and flexible models that demand cripplingly expensive retraining. In this episode, we dissect "Memento," a groundbreaking research paper that offers a third, far more elegant path forward. Inspired by human memory, Memento equips LLM agents with an episodic "Case Bank," allowing them to learn from experience just like we do.This isn't just theory. We explore the stunning results where this method achieves top-1 performance on the formidable GAIA benchmark and nearly doubles the effectiveness of standard approaches on complex research tasks. Forget brute-force parameter updates; this is about building AI with wisdom.Press play to discover the blueprint for the next generation of truly adaptive AI.In this episode, you will level up on:(02:15) The Core Dilemma: Why the current methods for creating adaptable AI agents are fundamentally unsustainable and what problem Memento was built to solve.(05:40) A New Vision for AI Learning: Unpacking the Memento paradigm—a revolutionary, low-cost approach that lets agents learn continually without altering the base LLM.(09:05) The Genius of Case-Based Reasoning: A simple explanation of how Memento's "Case Bank" works, allowing an AI to recall past experiences to make smarter decisions today.(14:20) The Proof Is in the Performance: A look at the state-of-the-art results on benchmarks like GAIA and DeepResearcher that validate this memory-based approach.(18:30) The "Less Is More" Memory Principle: A counterintuitive discovery on why a small, curated set of high-quality memories outperforms a massive one.(21:10) Your Blueprint for Building Smarter Agents: The key architectural takeaways and why this memory-centric model offers a scalable, efficient path for creating truly generalist AI.
Transcribe →
MemGPT: Towards LLMs as Operating Systems
Nov 100:18:08Tap to summarizeHave you ever felt the frustration of an LLM losing the plot mid-conversation, its brilliant insights vanishing like a dream? This "goldfish memory"—the limited context window—is the Achilles' heel of modern AI, a fundamental barrier we've been told can only be solved with brute-force computation and astronomically expensive, larger models.But what if that's the wrong way to think?This episode dives into MemGPT, a revolutionary paper that proposes a radically different, "insanely great" solution. Instead of just making memory bigger, we make it smarter by borrowing a decades-old, brilliant concept from classic computer science: the operating system. We explore how treating an LLM not just as a text generator, but as its own OS—complete with virtual memory, a memory hierarchy, and interrupt-driven controls—gives it the illusion of infinite context.This isn't just an incremental improvement; it's a paradigm shift. It's the key to building agents that remember, evolve, and reason over vast oceans of information without ever losing the thread. Stop accepting the limits of today's models and level up your understanding of AI's architectural future.In this episode, you'll discover:(00:22) The Achilles' Heel: Why simply expanding context windows is a costly and inefficient dead end.(02:22) The OS-Inspired Breakthrough: Unpacking the genius of applying virtual memory concepts to AI.(04:06) Inside the Virtual RAM: How MemGPT intelligently structures its "mind" with a read-only core, a self-editing scratchpad, and a rolling conversation queue.(05:05) The "Self-Editing" Brain: Witness the LLM autonomously updating its own knowledge, like changing a "boyfriend" to an "ex-boyfriend" in real-time.(08:40) The LLM as Manager: How "memory pressure" alerts and an OS-like control flow turn the LLM from a passive tool into an active memory manager.(10:14) The Stunning Results: The proof is in the data—how MemGPT skyrockets long-term recall accuracy from a dismal 32% to a staggering 92.5%.(13:12) Cracking Multi-Hop Reasoning: Learn how MemGPT solves complex, nested problems where standard models completely fail, hitting 0% accuracy.(15:51) The Future Unlocked: A glimpse into the next generation of proactive, autonomous AI agents that don't just respond, but think, plan, and act.
Transcribe →
DeepSeek-OCR: Contexts Optical Compression
Oct 2400:13:43Tap to summarizeThe single biggest bottleneck for Large Language Models isn't intelligence—it's cost. The quadratic scaling of self-attention makes processing truly long documents prohibitively expensive, a fundamental barrier that has stalled progress. But what if the solution wasn't more compute, but a radically simpler, more elegant idea?In this episode, we dissect a groundbreaking paper from DeepSeek-AI that presents a counterintuitive yet insanely great solution: Contexts Optical Compression. We explore the astonishing feasibility of converting thousands of text tokens into a handful of vision tokens—effectively compressing text into a picture—to achieve unprecedented efficiency.This isn't just theory. We go deep on the novel DeepEncoder architecture that makes this possible, revealing the specific engineering trick that allows it to achieve near-lossless compression at a 10:1 ratio while outperforming models that use 9x more tokens. If you're wrestling with context length, memory limits, or soaring GPU bills, this is the paradigm shift you've been waiting for.In this episode, you will discover:(02:10) The Quadratic Tyranny: Why long context is the most expensive problem in AI today and the physical limits it imposes.(06:45) The Counterintuitive Leap: Unpacking the "Big Idea"—compressing text by turning it back into an image, and why it's a game-changer.(11:20) Inside the DeepEncoder: A breakdown of the brilliant architecture that serially combines local and global attention with a 16x compressor to achieve maximum efficiency.(17:05) The 10x Proof: We analyze the staggering benchmark results: achieving over 96% accuracy at 10x compression and still retaining 60% at a mind-bending 20x.(23:50) Beyond Simple Text: How this method enables "deep parsing"—extracting structured data from charts, chemical formulas, and complex layouts automatically.(28:15) A Glimpse of the Future: The visionary concept of mimicking human memory decay to unlock a path toward theoretically unlimited context.
Transcribe →
A Definition of AGI
Oct 2300:19:55Tap to summarizeFor decades, Artificial General Intelligence has been a moving target, a nebulous concept that shifts every time a new AI masters a complex task. This ambiguity fuels unproductive debates and obscures the real gap between today's specialized models and true human-level cognition.This episode changes everything.We unpack a groundbreaking, quantifiable framework that finally stops the goalposts from moving. Grounded in the most empirically validated model of human intelligence (CHC theory), this approach introduces a standardized "AGI Score"—a single number from 0 to 100% that measures an AI against the cognitive versatility of a well-educated adult.The scores are in, and they are astonishing. While GPT-4 scores 27%, the next generation leaps to 58%, revealing dizzying progress. But the total score isn't the real story. The true revelation is the "jagged profile" of AI's capabilities—a shocking disparity between superhuman brilliance and profound cognitive deficits.This is your guide to understanding the true state of AI, moving beyond the hype to see the critical bottlenecks and the real path forward.In this episode, you will discover:(00:59) The AGI Scorecard: How a new framework, based on 10 core cognitive domains, provides a concrete, measurable definition of AGI for the first time.(02:56) The Shocking Results: Unpacking the AGI scores for GPT-4 (27%) and the next-gen GPT-5 (58%), revealing both massive leaps and a substantial remaining gap.(08:37) The Jagged Frontier & The 0% Problem: The most critical insight—why today's AI scores perfectly in math and reading yet gets a 0% in Long-Term Memory Storage, the system's most significant bottleneck.(13:12) "Capability Contortions": The non-obvious ways AI masks its fundamental flaws, using enormous context windows and RAG to create a brittle illusion of general intelligence.(16:21) AGI vs. Replacement AI: The provocative final question—can an AI become economically disruptive long before it ever achieves a perfect 100% AGI score?
Transcribe →
Teaching LLMs to Plan: Logical CoT Instruction Tuning for Symbolic Planning
Oct 500:16:30Tap to summarizeLarge Language Models (LLMs) like GPT and LLaMA have shown remarkable general capabilities, yet they consistently hit a critical wall when faced with structured symbolic planning. This struggle is especially apparent when dealing with formal planning representations such as the Planning Domain Definition Language (PDDL), a fundamental requirement for reliable real-world sequential decision-making systems.In this episode, we explore PDDL-INSTRUCT, a novel instruction tuning framework designed to significantly enhance LLMs' symbolic planning capabilities. This approach explicitly bridges the gap between general LLM reasoning and the logical precision needed for automated planning by using logical Chain-of-Thought (CoT) reasoning.Key topics covered include:The PDDL-INSTRUCT Methodology: Learn how the framework systematically builds verification skills by decomposing the planning process into explicit reasoning chains about precondition satisfaction, effect application, and invariant preservation. This structure enables LLMs to self-correct their planning processes through structured reflection.The Power of External Verification: We discuss the innovative two-phase training process, where an initially tuned LLM undergoes CoT Instruction Tuning, generating step-by-step reasoning chains that are validated by an external module, VAL. This provides ground-truth feedback, a critical component since LLMs currently lack sufficient self-correction capabilities in reasoning.Detailed Feedback vs. Binary Feedback (The Crucial Difference): Empirical evidence shows that detailed feedback, which provides specific reasoning about failed preconditions or incorrect effects, consistently leads to more robust planning capabilities than simple binary (valid/invalid) feedback. The advantage of detailed feedback is particularly pronounced in complex domains like Mystery Blocksworld.Groundbreaking Results: PDDL-INSTRUCT significantly outperforms baseline models, achieving planning accuracy of up to 94% on standard benchmarks. For Llama-3, this represents a 66% absolute improvement over baseline models.Future Directions and Broader Impacts: We consider how this work contributes to developing more trustworthy and interpretable AI systems and the potential for applying this logical reasoning framework to other long-horizon sequential decision-making tasks, such as theorem proving or complex puzzle solving. We also touch upon the next steps, including expanding PDDL coverage and optimizing for optimal planning.
Transcribe →
Five Orders of Magnitude: Analog Gain Cells Slash Energy and Latency for Ultra-Fast LLMs
Oct 500:17:22Tap to summarizeIn this episode, we explore an innovative approach to overcoming the notorious energy and latency bottlenecks plaguing modern Large Language Models (LLMs).The core of generative LLMs, powered by Transformer networks, relies on the self-attention mechanism, which frequently accesses and updates the large Key-Value (KV) cache. On traditional Graphical Processing Units (GPUs), loading this KV-cache from High Bandwidth Memory (HBM) to SRAM is a major bottleneck, consuming substantial energy and causing latency.We delve into a novel Analog In-Memory Computing (IMC) architecture designed specifically to perform the attention computation far more efficiently.Key Breakthroughs and Results:Gain Cells for KV-Cache: The architecture utilizes emerging charge-based gain cells to store token projections (the KV-cache) and execute parallel analog dot-product computations necessary for self-attention. These gain cells enable non-destructive read operations and support highly parallel IMC computations.Massive Efficiency Gains: This custom hardware delivers transformative performance improvements compared to GPUs. It reduces attention latency by up to two orders of magnitude and energy consumption by up to five orders of magnitude. Specifically, the architecture achieves a speedup of up to 7,000x compared to an Nvidia Jetson Nano and an energy reduction of up to 90,000x compared to an Nvidia RTX 4090 for the attention mechanism. The total attention latency for processing one token is estimated at just 65 ns.Hardware-Algorithm Co-Design: Analog circuits introduce non-idealities, such as a non-linear multiplication and the use of ReLU activation instead of the conventional softmax. To ensure practical applications using pre-trained models, the researchers developed a software-to-hardware methodology. This innovative adaptation algorithm maps weights from pre-trained software models (like GPT-2) to the non-linear hardware, allowing the model to achieve comparable accuracy without requiring training from scratch.Analog Efficiency: The design uses charge-to-pulse circuits to perform two dot-products, scaling, and activation entirely in the analog domain, effectively avoiding power- and area-intensive Analog-to-Digital Converters (ADCs).The proposed architecture marks a significant step toward ultra-fast, low-power generative Transformers and demonstrates the promise of IMC with volatile, low-power memory for attention-based neural networks.
Transcribe →
The Great Undertraining: How a 70B Model Called Chinchilla Exposed the AI Industry's Billion-Dollar Mistake
Aug 300:13:37Tap to summarizeFor years, a simple mantra has cost the AI industry billions: bigger is always better. The race to scale models to hundreds of billions of parameters—from GPT-3 to Gopher—seemed like a straight line to superior intelligence. But this assumption contains a profound and expensive flaw.This episode reveals the non-obvious truth: many of the world's most powerful LLMs are profoundly undertrained, wasting staggering amounts of compute on a suboptimal architecture. We dissect the groundbreaking research that proves it, revealing a new, radically more efficient path forward.Enter Chinchilla, a model from DeepMind that isn't just an iteration; it's a paradigm shift. We unpack how this 70B parameter model, built for the exact same cost as the 280B parameter Gopher, consistently and decisively outperforms it. This isn't just theory; it's a new playbook for building smarter, more efficient, and more capable AI. Listen now to understand the future of LLM architecture before your competitors do.In This Episode, You Will Learn:[01:27] The 'Bigger is Better' Dogma: Unpacking the hidden, multi-million dollar flaw in the conventional wisdom of LLM scaling.[03:32] The Critical Question: For a fixed compute budget, what is the optimal, non-obvious balance between model size and training data?[04:28] The 1:1 Scaling Law: The counterintuitive DeepMind breakthrough proving that model size and data must be scaled in lockstep—a principle most teams have been missing.[06:07] The Sobering Reality: Why giants like GPT-3 and Gopher are now considered "considerably oversized" and undertrained for their compute budget.[07:12] The Chinchilla Blueprint: Designing a model with a smaller brain but a vastly larger library, and why this is the key to superior performance.[08:17] The Verdict is In: The hard data showing Chinchilla's uniform outperformance across MMLU, reading comprehension, and truthfulness benchmarks.[10:10] The Ultimate Win-Win: How a smaller, smarter model delivers not only better results but a massive reduction in downstream inference and fine-tuning costs.[11:16] Beyond Performance: The surprising evidence that optimally trained models can also exhibit significantly less gender bias.[13:02] The Next Great Bottleneck: A provocative look at the next frontier—what happens when we start running out of high-quality data to feed these new models?
Transcribe →