Keeping up with AI

About Keeping up with AI

Keeping Up with AI is a podcast that helps you stay on top of the fast-moving world of artificial intelligence. The show breaks down the latest AI models, tools, breakthroughs, and workflows in a clear and practical way. Instead of chasing every headline, each episode focuses on what actually matters — the ideas, technologies, and productivity techniques that can help developers, builders, and curious professionals use AI more effectively.

Publisher

Swapnil Talekar

Category

technology

Language

en

Explicit

No

First episode

7 Mar 2026

Latest episode

10 Oct 2026

Latest episodes

15 episodes in the feed.

1. 

   10 Oct 2026

   The Decision Model Gold Rush

   A new kind of AI model called Jev launched on September 15. Within about two weeks, Amazon, OpenAI, Cloudflare, and a long list of open-source projects had shipped rivals. Jev is a decision model, which means it picks an answer instead of writing one. The answer can be a choice, a score, or a yes or no with a confidence number attached. In this episode, I step back from the question of which model is best, because any answer would be outdated before you finish listening. Instead, I focus on how to choose one for a real production pipeline. I start with why vendor benchmarks deserve some skepticism, and what the independent DecideBench results show about accuracy and cost. Then I walk through six questions to ask before you commit: where the model runs, what input it accepts, how fast it needs to be, whether its confidence scores hold up on your own data, what it costs at your volume, and how hard it would be to switch later. I also apply those questions to two very different scenarios, support ticket triage and a latency-sensitive trading or game loop, and I close with my prediction for where this category goes next. This episode is for developers, product managers, and engineering leaders. The full written post and all the links are in the show notes. ---- SHOW NOTES ---- Written post: https://swapniltalekar.substack.com/p/the-decision-model-gold-rush Earlier post on Jev (previous week): https://swapniltalekar.substack.com/p/jev-and-the-return-of-the-classifiers?r=1v4ea Models mentioned: Jev (TypeSafe), Strands Decider 2B (Amazon), Decisions API (OpenAI), Clef (Cloudflare), GLiDE and GLiNER2.5-Decide (Fastino), Imajev-4B, Laya, OpenJev, JevK5, von Benchmarks mentioned: DecideBench (Cho Yin Yong), JevBench Comparison table (first week of October 2026): see the written post

2. 

   5 Oct 2026

   Jev And The Return Of Classifiers

   TypeSafe's new model Jev has been billed everywhere as the end of hallucinations, and that framing is misleading. In this episode, I dig into what Jev actually is: a System One model that returns a structured decision instead of open-ended text, paired with a training method called RLCD that's built for calibration rather than raw accuracy. I walk through why this feels like a swing back to the classifiers we used before LLMs ate every decision-making task, why that framing alone undersells what's new here, and why calibration, not the absence of hallucination, is the real breakthrough. I also get into why Jev needs frontier-level text comprehension even though it never produces a word of output, why that makes it hard to benchmark, and why its calibration claims are still essentially a promise from TypeSafe until it's been tested at scale. Finally, I cover the practical limits worth knowing before you reach for it. If you've seen the hype and want the honest read on what Jev is actually good for, this one's for you.

3. 

   27 Sept 2026

   Should you be running local models for AI agents?

   Ever wonder why your AI agent burns through thousands of tokens just to say "hi"? In this episode, I break down what I learned after three months of running my own personal Hermes agent, and why I ended up completely rethinking how I run models for it. We dive deep into how agent frameworks actually use an LLM's context window, and why a single "hi" message can costanywhere from 10,000 to over 40,000 tokens. It's not a bug; it's what makes an agent an agent. From there, I walk through why local models and even frontiermodels like Claude and GPT became impractical for a hobby budget, a sneaky Hermes config bug that cost me weeks, and how I eventually landed on OpenRouter, a model gateway that turned out to be super useful. I cover automatic failover, multi-level caching, and why sticky sessions matter so much for agent workloads specifically. If you're building or running your own AI agent, this one willsave you some expensive trial and error. Show Notes Full article: "Should you be running LLM models locally for your agents? (https://swapniltalekar.substack.com/p/should-you-be-running-llm-models?r=1v4ea&utm_campaign=post&utm_medium=web)" — Swapnil Talekar's Substack Hermes config fix for the encrypted content error: set include_encrypted_content: false in ~/.hermes/config.yaml Models mentioned: Qwen-3.6-35B-A3B, DeepSeek-v4-Flash, NVIDIA Nemotron (free tier) Inference providers referenced: Together AI, Fireworks AI Gateway discussed: OpenRouter

4. 

   8 Sept 2026

   Running personal AI agents with Hermes

   Three months ago, I gave up on OpenClaw and switched to Hermes for running my own personal AI agents, and I've been living with it since. In this episode, I walk through what actually changed. Everything that I learnt and everything that surprised me. I talk about some of the Hermes internals and what makes it so powerful: profiles that isolate memory, workspace, and even the messaging gateway per agent, which is the single feature that makes Hermes feel more like actually distinct agents. I get into the three agents I use daily: a personal accountantthat watches my investments, a health coach that logs my meals and workouts over Telegram, and a Montessori teacher for my four-year-old, plus how I picked cheap, capable models through OpenRouter instead of running anything locally. I also cover what hasn't gone smoothly: agents that mark work done without checking it, a genuinely strange recurring date bug that hit two unrelated agents, and one agent that looped a hundred and fifty times fixing a bug that turned out to be one missing HTML tag. This one's for anyone experimenting with personal AI agents, or thinking about it- developers and tinkerers especially- or anyone curious what living with an always-on AI assistant is actually like. Full Substack article -https://swapniltalekar.substack.com/p/three-months-of-running-personal?r=1v4ea (Three months ago, I gave up on OpenClaw and switched to Hermes for running my own personal AI agents, and I) (Three months ago, I gave up on OpenClaw and switched to Hermes for running my own personal AI agents, and I)

5. 

   23 Aug 2026

   The Truth About Mult-Agent Workflows

   Everyone on AI Twitter seems to be running a twelve-agent swarm that ships products while they sleep. Meanwhile, most real workflows still look like three chat tabs and a lot of copy-pasting. In this episode, I dig into whether multi-agent workflows are real or mostly marketing. I break down how Claude, Cursor, and Codex each approach running multiple agents at once: Claude's Agent Teams, with a team lead, a shared task list, and file locking; Cursor's orchestration workspace, including Best of N and Build in Parallel; and Codex as a specialist agent that other systems orchestrate around. I walk through the five patterns that actually show up in practice, plan-build-review, parallel research, role specialization, best-of-N comparison, and long-task splitting, and explain why splitting work across agents still beats one super-agent, even as models get smarter. This episode is for developers, engineering leaders, and product managers working with AI tools day to day. If you're AI-curious but non-technical, it's a good listen for thinking about how these patterns might apply to your own work eventually. Substack article link - https://swapniltalekar.substack.com/p/are-managers-really-becoming-better?r=1v4ea

6. 

   10 Aug 2026

   Agent memory and state patterns for loops

   This episode is part of my loop engineering series, and it's about the piece that decides whether a loop actually gets better over time: memory. I talk about what memory actually is, since it gets confused with two other things constantly: the context window, which disappears the moment a session ends, and a project knowledge file, which stays static across runs. Memory is neither. It's the dynamic record of what a loop decided, what failed, and what's still open. From there I walk through three memory patterns, starting with the flat text file, through task trackers, to structured stores for when semantic search actually earns its complexity. I cover how to wire memory updates into hooks so they happen automatically, and four specific ways memory setups break in practice. Hope you find it useful. Show Notes Full article: Substack link (https://swapniltalekar.substack.com/p/agent-memory-and-state-patterns-for?r=1v4ea&utm_campaign=post&utm_medium=web) Related episodes: Loop Engineering: Putting agents on Autopilot (https://open.spotify.com/episode/6CrFYHBvOOakhMvI8Z1jQz?si=YRYThb1lSoemNxk4NyPUvA) The missing guide for AI Agent Skills – Part I (https://open.spotify.com/episode/4TAYFQGxUaY2xwYky3nBTE?si=uq9iB_USTGCb8tz1B3iCTQ) The missing guide for AI Agent Skills – Part II (https://open.spotify.com/episode/6dpnb8k8nZFebPP1qDCZ8h?si=9NK0KS2eRWeGAj7vDVbkag) Coming soon: Parallel agents — worktrees, sub-agents, and Agent Teams

7. 

   25 Jul 2026

   The missing guide for AI Agent Skills - Part 2

   Most skills start useful and quietly get worse. Not because the feature is flawed, but because skills encode assumptions, and assumptions go stale: file paths, command sequences, team conventions, tool names. All of that changes, and the skill keeps looking authoritative while describing a world that no longer exists. In this episode, part two of the Claude Code skills series, I cover how to write skills that resist that decay and how to manage them once you have more than a handful. I get into why avoiding hardcoded paths and writing the reasoning behind an instruction, not just the instruction itself, makes a skill survive the changes that kill brittle ones. I break down the real token cost of a bloated SKILL.md file, including the exact compaction and description budgets Claude Code enforces, and where the practical ceiling on total skills sits before descriptions start getting silently trimmed. I also cover the difference between team skills and personal ones, the review discipline most teams skip, and the quarterly audit habit that keeps a skill library from decaying into noise. If you're building any kind of skill library, whether shared with a team or just for yourself, this episode is the maintenance manual for keeping it worth trusting. Show Notes: Part 1 of Skills podcast - https://spotifycreators-web.app.link/e/xk601uOfJ4b ( https://spotifycreators-web.app.link/e/xk601uOfJ4b) Substack post - https://open.substack.com/pub/swapniltalekar/p/a-deep-dive-on-skills-part-2?r=1v4ea&utm_campaign=post-expanded-share&utm_medium=web (https://open.substack.com/pub/swapniltalekar/p/a-deep-dive-on-skills-part-2?r=1v4ea&utm_campaign=post-expanded-share&utm_medium=web)

8. 

   19 Jul 2026

   Loop Engineering: Putting agents on autopilot

   Loop engineering is having a moment. Boris Cherny and Peter Steinberger have both said the same thing in public: stop prompting your coding agent turn by turn, and start designing systems that prompt it for you. This episode is the implementation guide. I walk through the five building blocks a real loop needs: automations and hooks, git worktrees for isolating parallel agents, skills for persistent project knowledge, MCP connectors that let a loop touch your actual tools, and sub-agents that separate the agent doing the work from the agent checking it. Then I walk through a complete example, an unattended loop. I also cover what most posts on this topic skip: how many turns to let a loop run before you step in, what a loop actually costs, and the handful of decisions that should never run unattended. Show Notes Substack article: https://swapniltalekar.substack.com/p/loop-engineering?r=1v4ea ( https://swapniltalekar.substack.com/p/loop-engineering?r=1v4ea) Tools and references: Addy Osmani's original piece on loop engineering— https://addyosmani.com/blog/loop-engineering (https://addyosmani.com/blog/loop-engineering ) Peter Steinberger's post — https://x.com/steipete/status/2063697162748260627 (https://x.com/steipete/status/2063697162748260627) /goal and /loop — Claude Code's two core commands for building loops --max-turns — flag to cap how many turns a /goal runs Hooks: PreToolUse, PostToolUse, configured in .claude/settings.json isolation: "worktree" — flag for spawning a sub-agent in an isolated git worktree SKILL.md — project knowledge file; see the Skills series below for the full breakdown MCP connectors — GitHub, Linear, Slack, database integrations Sub-agents — defined as markdown files in .claude/agents/ Related episodes: https://open.spotify.com/episode/4TAYFQGxUaY2xwYky3nBTE?si=uq9iB_USTGCb8tz1B3iCTQ (https://open.spotify.com/episode/4TAYFQGxUaY2xwYky3nBTE?si=uq9iB_USTGCb8tz1B3iCTQ)

9. 

   3 Jul 2026

   The missing guide for AI Agent Skills

   If you've set up a skill in Claude Code and watched Claude ignore it, this episode is about why that happens. Skills are one of the most useful features in Claude Code, but the way they actually work is different from what most tutorials suggest. They're not always loaded into context. The triggering mechanism is narrower than it looks. And "always do X" in a skill body is a strong default, not a guarantee. In this episode, I cover the fundamentals: what a skill actually is, how lazy loading works and why it matters, and how skills fit alongside Claude.md and MCP. Then I get into the part most tutorials skip, which is the triggering problem. Why descriptions fail silently, what kills auto-triggering without any error message, and how to diagnose it. I also cover the difference between soft and hard enforcement, and when you should be reaching for hooks instead of skill instructions. This is part one of two. Part two covers writing skills that stay useful over time, token efficiency, and what a well-maintained skill library looks like for a team. If you're building with Claude Code or trying to get more out of it, this one is worth your time. Full article: https://open.substack.com/pub/swapniltalekar/p/a-deep-dive-on-skills-part-i?r=1v4ea&utm_campaign=post&utm_medium=web (https://open.substack.com/pub/swapniltalekar/p/a-deep-dive-on-skills-part-i?r=1v4ea&utm_campaign=post&utm_medium=web) Tools and references mentioned: AgentSkills open standard - agentskills.io (https://agentskills.io) Debug flag for YAML parse errors: claude --debug disable-model-invocation: true — frontmatter flag that prevents Claude from auto-triggering a skill user-invocable: false — frontmatter flag that hides a skill from the slash menu but allows auto-triggering skillOverrides: settings option to change skill visibility without editing SKILL.md PreToolUse hooks: hard enforcement that runs before every tool call; exit code 2 blocks the action unconditionally disallowed-tools — frontmatter field that removes specific tools from Claude's available pool while a skill is active Preprocessing syntax: add !before a backtick-wrapped shell command in SKILL.md to run it before the skill loads

10. 

    13 Jun 2026

    Is AI making engineering teams slower?

    AI Writes More Code. Why Are Engineering Teams Shipping Slower? Here's the paradox: AI can write code 5x faster than humans. Yet many engineering teams aren't shipping faster. Some are actually shipping slower. In this episode, I break down why code generation speed doesn't translate to shipping speed. The cost of writing code has collapsed, which creates a new constraint: review capacity, architectural decisions, and judgment. These are the real bottlenecks now. I explore what happens when you can generate thousands of lines of code in hours but need senior engineers to validate all of it. How architectural entropy spreads when each engineer uses AI to solve similar problems differently. Why the skill that matters most isn't code generation anymore. It's deciding which code is actually worth shipping. We also talk about engineers who've never coded without AI. What happens when you can build features but can't explain how they work. And how to recognize if this shift is happening in your own organization. The teams winning with AI aren't trying to maximize code output. They're maximizing decision quality. They're treating AI like a capable junior engineer who needs oversight, not autonomy. If you're leading an engineering team, this episode is for you. Substack article - https://swapniltalekar.substack.com/p/ai-writes-more-code-why-are-engineering?r=1v4ea (https://swapniltalekar.substack.com/p/ai-writes-more-code-why-are-engineering?r=1v4ea)

11. 

    6 Jun 2026

    Spec-driven development for AI agents

    I keep meeting young developers who are frustrated with AI coding tools. The output is inconsistent, the context is missing, and fixing the first draft takes longer than writing it themselves. The common diagnosis is that the model is bad. I don't think that's it. The real problem is the spec, and most developers skip writing one entirely. In this episode, I break down spec-driven development: what it is, why it's gaining serious traction in engineering teams right now, and how companies like GitHub and AWS are building entire tooling ecosystems around it. I also talk about the difference between a Jira ticket, a plan, and an actual spec, because they are not the same thing. And I walk through grill-me, a Claude Code skill that replaces cold spec-writing with a structured conversation. It's one of the most practical changes I've made to my workflow, and I share a real example of what that session looks like in practice. If you've been getting inconsistent output from AI coding agents, this episode is worth your time. If you prefer reading, I've also published this entire episode on my substack Substack link - https://swapniltalekar.substack.com/p/why-better-prompts-wont-fix-your?r=1v4ea (https://swapniltalekar.substack.com/p/why-better-prompts-wont-fix-your?r=1v4ea)

12. 

    30 May 2026

    RAG for agentic era

    The prompting vs. RAG vs. fine-tuning debate is not over. It just moved to the wrong level. Most teams building with LLMs are still applying a 2023 framework to 2026 agent systems. The classic ladder model, start with prompting, add RAG for knowledge, fine-tune as a last resort, was built for single-turn systems. In an agent, all three techniques play completely different roles than that framework assumes. In this episode, I break down what actually changed. We cover how RAG evolved from static pipelines to agentic self-correction, why Anthropic's Claude Code team abandoned vector RAG entirely in favor of grep-style search, and what the shift toward context architecture and MCP means for how you build today. We also get into where prompting actually breaks in multi-step agents, and which fine-tuning targets move the needle in agentic systems (hint: it's not response style). The episode closes with a practical diagnostic framework for identifying which layer of your agent is failing before you reach for a solution. If you're building agentic systems and finding that your architecture feels more expensive than it should be, this one is for you. Substack link - https://swapniltalekar.substack.com/p/rag-for-agentic-era?r=1v4ea (https://swapniltalekar.substack.com/p/rag-for-agentic-era?r=1v4ea)

13. 

    23 May 2026

    Decoding OpenClaw

    What happens when a single developer, working alone over a weekend, ships something that leaves Microsoft, Google, and a dozen well-funded AI startups in the dust? That's the OpenClaw story, and it says a lot about where AI agents are actually headed. In this episode, we break down how OpenClaw went from an unnamed GitHub repo to tens of thousands of waitlist signups in under 48 hours, and the four specific design decisions that made it explode when similar tools quietly fizzled. We also cut through the influencer hype. Yes, people used it to order food from Swiggy, and no, that's not the point. We walk through three use cases where OpenClaw actually earns its setup cost: intelligent competitor monitoring, an always-on personal finance manager that sends you weekly WhatsApp digests, and an async personal shopper that watches prices so you don't have to. Plus, the practical stuff: cloud hosting options from as little as six dollars a month, and the security basics you need in place before you connect anything real. OpenClaw may not be the final form of AI agents. But the category it represents, persistent and proactive agents that live in your workflow rather than asking you to change it, is the category that matters. If you've been trying to make sense of the AI agent landscape, this episode is your map. Substack article - https://swapniltalekar.substack.com/p/the-openclaw-story?r=1v4ea (https://swapniltalekar.substack.com/p/the-openclaw-story?r=1v4ea)

14. 

    13 Mar 2026

    Claude Code for Non-Coders

    Are you drowning in digital files, spending hours on repetitive tasks that feel like they should be automated? In this episode of Keeping up with AI, we dive deep into Claude Code - one of my favourite and most versatile AI tools that's not just for programmers. Never mind the name. Whether you're a researcher organizing hundreds of PDFs, a content creator managing multiple projects, a business analyst wrestling with messy spreadsheets, or simply someone tired of their chaotic Downloads folder, this episode will fundamentally change how you think about productivity. We'll explore how Claude Code works directly with your actual files and folders, performing batch operations that would normally take hours or days and compressing them into minutes – all through simple, plain English instructions. We'll walk through some real-world examples including document processing, data cleaning, content creation, and intelligent file organization. We'll also provide essential tips for first-time users. By the end of this episode, you'll understand why having an AI that can actually touch your files – not just advise you about them – is an absolute game-changer, and you'll have the knowledge to start automating your own workflows immediately even if you have no coding experience.

15. 

    7 Mar 2026

    Hello World!

    Artificial Intelligence is moving faster than any technology in history. Every week there’s a new breakthrough — and a flood of headlines, opinions, and hype. For many of us, keeping up can feel overwhelming. Keeping Up with AI is a podcast designed to cut through that noise. The podcast distills the most important developments in the AI world into clear, practical insights. Instead of trying to cover everything, each episode focuses on what actually matters — the tools, workflows, ideas, and breakthroughs that can meaningfully impact how we work, build, and think about technology. Whether you're a developer, a product builder, a tech enthusiast, or simply someone curious about how AI is shaping the future, this podcast will help you stay informed without drowning in information. In every episode, you’ll get: Clear explanations of the most important AI developments Practical tools and workflows you can start using today Insights into how AI systems and models actually work Thoughtful analysis on what changes matter — and what doesn’t If AI feels like it’s moving too fast to follow, this podcast is here to help you keep up — calmly, clearly, and intelligently.

Reach and audience

Public platform figures. Ratings count people who left a rating, not total listeners.

Spotify

5.0 / 5

2 ratings

Contact Keeping up with AI

Guest appearances

Does not typically book guests

Based on episode analysis; this does not confirm that the show is currently accepting guests.