Advertise on podcast: Intelligent Insights

Gartner expects about 40% of agentic AI projects to be canceled by 2027. Only around 17% of organizations have actually deployed agents, even though more than 60% plan to. This episode covers the first three parts of my series, Enterprise AI in Production, and looks at why a great agentic demo so often stalls before it reaches production. We cover: Predictability. Can we audit it, reproduce it, and put an SLA on it? These are enterprise software questions, not AI questions, and they decide what goes live.Cost. An agent that keeps reasoning keeps spending tokens. Why cost per decision matters, and why paying to re-solve problems you already solved is the hidden waste.Trust. Enterprises buy confidence, not capability. We walk through the four questions that decide whether something ships: explainability, reproducibility, auditability and accountability.The pattern that connects all three: AI should discover, and deterministic systems should execute. Once AI reliably solves a class of problems, turn that into a rule or workflow. It then runs cheaply, the same way every time, and a regulator can inspect it. Capability gets you the meeting. Confidence gets you the deployment. Where have you drawn the line between reasoning and execution in your systems? I'd like to hear. #EnterpriseAI #AgenticAI #AIinProduction #AIGovernance

AI agents can plan, re-plan, call tools, reflect, and keep reasoning. That flexibility is powerful—but every reasoning step costs money. In Part 2 of Enterprise AI in Production, I look at one of the biggest challenges in taking agentic AI from demo to production: unpredictable cost. The important question isn't simply how much an AI model costs. It's: What does one business decision cost—and can we bound that cost? When an agent repeatedly reasons through a problem it has already solved hundreds or thousands of times, we're paying premium token costs to rediscover something the system already knows. A better pattern is to let reasoning earn its retirement. Use AI for genuinely new, ambiguous, or difficult problems. Once a behavior becomes stable and repeatable, convert it into a deterministic rule, workflow, cached decision, or ordinary code. You don't lose the intelligence. You bank it. In this episode: • Why autonomous agents can create unpredictable operating costs• Why cost per decision matters more than token cost alone• The hidden cost of repeatedly solving the same problem• How to identify workflows that should move off the reasoning path• Why reasoning should be a phase—not a permanent state• How hybrid AI architectures can improve enterprise ROI The goal isn't to use less AI. It's to make sure we're paying for reasoning only when reasoning is creating new value.

Agentic AI can look impressive in a demo. Production is where the difficult questions begin. Can the system be audited? Can its decisions be reproduced? What happens when the underlying model changes? Can it meet compliance requirements, control costs, and guarantee reliable execution? In this episode: • Why autonomous-agent architectures struggle at production scale• The difference between AI reasoning and system execution• Why predictability matters more than adding more AI• How hybrid architectures balance intelligence and control• When AI-discovered solutions should become deterministic workflows Next episode: Why reasoning is expensive—and execution should become cheap.

AI agent loops are becoming one of the most important design patterns in modern software development. Instead of using AI only as a chat assistant, teams are now experimenting with autonomous loops where agents can pick up tasks, write code, review changes, fix errors, and continue working through structured feedback cycles. In this episode of Intelligent Insights, we explore the systems design and implementation strategy behind agent loops. We look at how tools like Claude Code and specialized coding agents can improve productivity by handling repetitive engineering workflows such as backlog processing, code generation, testing, and review cycles.

Autonomous AI agents are moving beyond simple chat interfaces and experimental demos. But how should we actually design them for real-world systems? In this episode of Intelligent Insights, we explore the engineering logic behind agentic AI architecture. The episode introduces a two-dimensional framework for understanding AI agents based on both their cognitive function and execution topology. Instead of looking only at how data flows through an agent system, this approach helps distinguish agents by what they are thinking, planning, deciding, and coordinating. We break down key design patterns such as ReAct, Plan-and-Execute, and Multi-Agent Orchestration, while also discussing practical production concerns like context engineering, memory, reflection, reliability, cost control, and governance. This episode is for developers, architects, product builders, and AI leaders who want to move from agent prototypes to scalable, predictable, and production-ready agentic systems.

In this episode of Intelligent Insights, we explore a new class of cybersecurity risks emerging with autonomous AI agents. Traditional security focuses on protecting networks, systems, and data, but AI agents introduce a deeper challenge: protecting the reality they perceive. Based on Google DeepMind’s research on AI agent traps, this episode breaks down how attackers can manipulate the information environment around AI systems through hidden content, behavioral control, poisoned knowledge bases, human approval fatigue, and systemic multi-agent failures. We discuss why web agents, RAG systems, enterprise copilots, and autonomous workflows may be vulnerable when they trust machine-readable data without enough verification. The episode also examines the bigger question: if an AI agent makes a harmful decision based on manipulated memory or poisoned context, who is responsible — the developer, the company, the executive, or the human who approved the output?

What actually powers modern AI coding agents like Claude Code? In this episode of Intelligent Insights, we take a deep technical dive into the architectural foundations of agentic AI systems through the lens of Claude Code and comparable open-source implementations. While most discussions focus on the intelligence of large language models, the real engineering complexity lies elsewhere — in the orchestration layers surrounding the model itself. This episode also examines the broader future of agentic systems in enterprise software and the open questions surrounding long-term human dependency on AI-driven development tools. If you're interested in AI engineering, autonomous systems, enterprise AI architecture, or the future of software development, this episode is for you.

We often think of AI as intelligence — models that reason, generate, and decide. But in real-world systems, intelligence is only a small part of the story. In this episode, we explore a deeper truth: modern AI systems are not defined by the model alone, but by the infrastructure that surrounds it. From permission layers and tool orchestration to context management and safety controls, the majority of what makes AI work lies outside the model itself. Why is intelligence only a fraction of the system?What makes an AI agent reliable, controllable, and production-ready?And why are the most important design decisions happening beyond the model? This episode breaks down the hidden architecture behind today’s AI systems — and what it means for anyone building, scaling, or evaluating AI in the real world.

AI is evolving beyond pure deep learning. In this episode, we explore how Transformers revolutionized machine intelligence and how Neuro-Symbolic AI may define the next wave.A must-listen for leaders, builders, and anyone shaping the future of AI systems.

Artificial Intelligence is transforming the global labor market - but not in the way most people expect. Instead of triggering a mass job apocalypse, AI is driving a structural recomposition of work. Many routine tasks are being automated, but entirely new roles are emerging at the intersection of human judgment and AI systems. In this episode of Intelligent Insights podcast, we explore why high-paid professionals are increasingly exposed to AI automation, and why the biggest impact may actually be felt in white-collar knowledge work.

Anthropic’s Agent Skills introduce a smarter way for AI agents to load knowledge only when it’s needed. Using progressive disclosure, agents stay token-efficient while gaining powerful, domain-specific capabilities on demand. In this episode, we explain how Agent Skills work, why they’re simpler than MCP, and how they turn general AI models into focused specialists—while raising important security questions around executable skills. If you’re building or thinking about AI agents, this is a format you’ll want to understand. Powered by ideas from Anthropic.

Clawdbot (now Moltbot) is a powerful local-first, open-source agentic AI assistant that runs on your own hardware and can act across emails, messages, and system commands. In this episode of Intelligent Insights, we unpack how this autonomous AI works, why it went viral, and what went wrong—from a trademark dispute with Anthropic to security concerns around deep system access. A sharp look at the promise—and the risks—of truly autonomous personal AI.

Most AI initiatives don’t fail because the models are weak - they fail because organizations never design for reality. In this episode of Intelligent Insights, we unpack why 80 - 95% of enterprise AI pilots never make it to production, and what separates scalable AI systems from endless proof-of-concepts. Drawing from industry research and real-world engineering patterns, we explore the hidden blockers behind “pilot purgatory” — including verification tax, MLOps immaturity, technical debt, and misaligned incentives. We break down a practical roadmap for scaling AI responsibly, starting with high-control, low-agency systems and gradually increasing autonomy as trust is earned. You’ll learn why Human-in-the-Loop (HITL) frameworks, disciplined data foundations, and cost-aware hosting strategies matter more than choosing the latest model. This episode is not about hype. It’s about shipping AI that survives contact with production. If you’re a product leader, engineer, founder, or executive trying to move AI from demos to durable business impact - this one’s for you.

Do you really need a trillion-parameter model to solve enterprise problems? In this episode, we unpack why Small Language Models (SLMs) are gaining momentum across enterprise AI. We explore how techniques like knowledge distillation and quantization allow smaller models to deliver competitive performance - while significantly reducing cost, latency, and energy consumption. We also discuss why SLMs are a natural fit for agentic AI, enabling multi-step reasoning, on-device and on-prem deployments, and stronger data privacy in regulated environments. The takeaway: the future of AI isn’t just about bigger models, but smarter architectures built for real-world production.

AI is entering a new phase.In 2026, the conversation is no longer about basic automation or copilots - it’s about agentic AI: autonomous systems that reason, decide, and execute work across functions. In this episode, I break down six defining AI trends for 2026, drawing from multiple industry reports and real-world adoption patterns. We explore why AI agents promise massive productivity gains - and why trust, data quality, and governance remain the biggest blockers to scale. You’ll learn why context engineering matters more than prompt engineering, how successful teams combine AI autonomy with human oversight, and what practical strategies actually reduce legal, ethical, and operational risk. If you’re building, leading, or investing in AI systems - this episode is about what works in practice, not what sounds good in demos. This episode is for product leaders, engineers, and executives navigating real-world AI adoption in 2026.