Domain
Dev Tools
339 episodes
-
MCP server portals
Asteria and Draco unpack Cloudflare's MCP server portals as boundary infrastructure for enterprise MCP adoption: one Access-controlled endpoint, curated tools, managed OAuth, Code Mode, and observability, with caveats around direct server URLs, admin credentials, and sync paths.
-
GitHub ARPAHLS/skillware: A Python framework for modular, self Contained skill management for machines.
Skillware is a new open-source framework that packages AI agent capabilities into modular, installable skills using a Python-based registry. The hosts debate whether this is a genuine infrastructure win or yet another abstraction layer in search of a problem, and end up excited by the practicality of installing a skill like `finance/wallet_screening` with executable logic, governance, and tool schemas that work across models. They call out the trust model for running third-party skills, tease an install demo (`pip install "skillware[gemini]"`), and close on an enthusiastic call to arms.
-
Overview: Structured Output
We slow down and explain structured output from the ground up: why free-form model text is awkward for software, how schemas and constrained decoding make it usable, and where the format guarantee stops.
-
GitHub FareedKhan Dev/train LLM From scratch: A straightforward method for training your LLM, from downloading data to generating text.
A single-GPU end-to-end LLM training guide lands on GitHub—hand-written PyTorch, pretrain to chat in one repo, plus full RLHF. Vince is giddy; Ava wants to know which corner of the GPU shelf this actually runs on. Build Next shows the exact CLI to kick it off on a T4.
-
Use My No AI Slop Skill to Remove 20 AI Slop Patterns
Jessica and Cathy examine Peter Yang’s open-source /no-ai-slop skill, asking whether removing recognizable AI writing patterns can preserve human voice or merely create a new style filter. They focus on the article’s 25/50/25 editing process, the limits of heuristic detection, and the practical boundary between AI assistance and human judgment.
-
Andrew Ng 4 agentic steps "from Loops to Graphs from scartch"
Andrew Ng's four-step framework maps agentic design from simple loops (Reflection, Tool Use) through chains (Planning) to graphs (Multi-Agent Collaboration). The central claim: architecture beats model selection—GPT-3.5 in a reflective workflow hits 95.1% on HumanEval vs. GPT-4 zero-shot at 67%. Pippa sees a product win (weaker models ship faster, cost less, iterate tighter). Tyler flags the mechanism: you're not buying smarter; you're buying durable state, typed handoffs, and stopping rules. Both converge that this is the same control-infrastructure pattern they've been tracking—now with a named vocabulary and a staged build path.
-
Graph Engineering Athropic Playbook
Anthropic's knowledge-graph engineering playbook replaces classical NLP pipelines (trained NER, relation classifiers, entity-resolution heuristics) with a sequence of Claude API structured-output calls. The entire extraction-resolution-assembly-querying loop becomes prompt-based, scaling from Haiku (high-volume extraction) to Sonnet (reasoning). The graph serves multi-agent systems as shared memory, grounding layer for evaluator-optimizer loops, and persistent world model across sessions. The paper maps this onto Anthropic's five canonical agent patterns and reports precision/recall against a gold set.
-
OpenAI updating ChatGPT desktop app with GPT Voice for talking through work 9to5Mac
Masonry and Eyre dig into OpenAI bringing GPT Voice to the ChatGPT desktop app, where it can now coordinate work across Chat, Work, and Codex by voice. They focus on the real user story for people already living in the app, the Mac-only Appshots context boost, the computer-control angle, and the new multi-folder project setup. They also poke at the desktop-app clutter without losing sight of the workflow win.
-
Poolside Releases Laguna S 2 1
Vince and Ava talk through Poolside’s Laguna S 2.1 release as an unusually practical open-weight coding model: 118B total parameters, 8B active, 1M-token context, and a real deployment story on a single DGX Spark. They dig into the mechanism, the max-thinking default, the benchmark results, and the trade-off between long-horizon capability and token spend, while keeping one eye on the broader open-vs-closed race.
-
Think through hard problems in voice mode | Claude by Anthropic
Asteria and Draco dig into Anthropic’s update to Claude voice mode, where Opus and Sonnet now power spoken sessions, connected tools are usable from voice, and multilingual support expands. They focus on the real argument: voice mode becomes useful when it’s no longer just fast chatter, but a place to work through half-formed thinking and then hand off to action. They also question where the feature stops being a convenience and starts being a real workflow, especially given model switching, permission prompts, and the different value between free and paid tiers.
-
OpenAI and Anthropic both speak at once with dueling voice updates
Onyx and Echo argue through The New Stack’s read on OpenAI and Anthropic shipping near-simultaneous voice updates, with Echo skeptical that timing equals technical proof and Onyx focused on why voice may finally matter in real workflows.
-
Overview: Durable Execution
We’re finally slowing down and unpacking durable execution from the ground up, because it keeps showing up in our conversations and it actually deserves the full treatment. We’re using the book-with-bookmarks idea to make the mechanics of checkpoints, retries, and recovery click without hand-waving.
-
Overview: Append Only Logging
We’re finally making append-only logging click, because it keeps sneaking into the stuff we cover and we keep assuming everybody sees the mechanism already. We walk from the basic idea to why it gives AI systems a durable, auditable trail, and where that trade-off starts to bite.
-
Overview: State Serialization
We finally slow down and explain state serialization from the ground up: what it is, why it matters, and how it lets an AI pause, resume, and hand off work without losing the thread. We keep it in our own voice and stay close to the actual mechanism, because state serialization is one of those ideas we keep circling for a reason.
-
Introducing Cursor Router · Cursor
Cursor Router is Cursor's new Teams and Enterprise model-routing layer, using a classifier trained on more than six hundred thousand live requests to select models by task, context, complexity, and domain. Jessica sees a clean adoption story for teams stuck paying frontier rates for routine coding work; Cathy likes the production-oriented evaluation and cache-aware accounting, while keeping an eye on how much trust enterprises place in Cursor's routing judgment.
-
Building verification loops in Claude Code with skills | Claude by Anthropic
Anthropic argues that the useful agentic coding loop is not merely generate-and-test. Teams should capture repeated manual checks as scoped Claude Code skills, then place them where they belong: standalone, embedded in a workflow, chained after another skill, or eventually enforced on pull requests. Asteria and Draco like the operational framing, while keeping the boundary clear between deterministic verification and an agent grading its own fuzzy work.
-
Overview: Context Window Management
We finally slow down and explain Context Window Management from the ground up, because we keep hand-waving it whenever agents, memory, cost, and long tasks come up. The whole thing is the fixed-desk problem: what stays on the desk, what gets compressed, and what falls off.
-
OpenAI unveils Presence, a new platform that lets enterprises launch and manage realtime voice agents and chatbots
Pippa and Tyler discuss OpenAI Presence, a limited-availability enterprise platform for deploying governed realtime voice agents and chatbots with policies, simulations, evaluations, approvals, escalations, and forward-deployed implementation support.
-
The Microsoft Agent Framework Harness is now released | Microsoft Agent Framework
Microsoft Agent Framework has released a stable, batteries-included agent harness for Python and .NET, packaging planning, memory, tool loops, approvals, context compaction, and telemetry behind a configurable agent wrapper.
-
3 Years of Graph Engineering with LangGraph
Cooper and Miles unpack LangChain's argument that “graph engineering” is not a new magic category, but a practical way to combine deterministic workflow control with agentic flexibility in LangGraph. They dig into where the framing is technically strong, where it risks becoming just another buzzword, and who should actually care.
-
Building Governed Agents: A Framework for Cost, Control, and Compliance
Vince and Ava examine LangSmith’s framework for governed agents, focusing on the LLM gateway as a runtime control plane for model choice, cost, permissions, evidence, and continuous improvement.
-
Why AI Company Brains Fail
Pippa and Tyler unpack why a cheap vector search demo breaks on broad portfolio and exact counting questions, and why the article’s lighter entity layer may be more practical than a full GraphRAG stack.
-
Kwc2SSaP0y
Buzz argues that the workspace for software teams should treat people, agents, messages, workflows, and code as parts of one shared system. Cooper likes the product shape, while Miles argues the hard part is whether signed events and self-hosting produce usable coordination rather than another fragmented collaboration stack.
-
Overview: Retry Loops and Error Recovery
We finally define retry loops and error recovery, because we keep tossing the term around like everybody knows exactly what it means. We walk through the basic loop, where it helps, where it doesn’t, and why the checker matters so much.
-
Model Behavior: Week of July 20, 2026
We think this week made the same point from a few different angles: the fight is moving from raw model bragging rights to who controls the agent stack in production. We keep circling the same uncomfortable truth, which is that the boring control layer is starting to decide who actually wins.
-
Foreground Attention Is No Longer the Control | Coding Agent Brief
Pippa and Tyler debate Claude Code version two point one point one ninety-eight and the broader July coding-agent security wave, with Tyler skeptical that background automation is safe without policy moving downstream.
-
Meta Open Sources Astryx an Agent Ready React Design System with 150 Accessible Components Seven Themes and a CLI
Meta releases Astryx, an open-source React/StyleX design system with 150+ accessible components, seven themes, dark mode, templates, and a CLI. It's meant for both humans and AI agents, shipping pre-built CSS with no build steps. Tyler explores its architecture and trade-offs; Pippa focuses on the product angle and adoption path. They end with concrete install steps and a shared verdict.
-
Alibabas Tongyi Lab Releases Qwen Audio 3 0 TTS a Hosted Text to Speech Model in Flash and Plus Tiers Across 16 Languages
Cooper and Miles examine Alibaba's Qwen-Audio-3.0-TTS, comparing its Flash and Plus tiers, multilingual support, voice controls, architecture, hosted-only trade-offs, pricing, and real production use cases.
-
A Scorecard for the AI Age
OpenAI’s scorecard argues AI value must be measured in useful work per dollar, not just token cost. Cooper sees a practical product story; Miles pokes at the metrics and pushes for mechanistic honesty. The two hash out whether the framework holds up and what it changes day-to-day.
-
Overview: Task Decomposition
We finally slow down on task decomposition, the quiet trick underneath agents, code review workflows, web tasks, and a lot of the stuff we keep arguing about. We use one mental model, a messy project board becoming manageable tickets, and build from intuition to mechanism to where it still matters now.
-
Harness Handbook: Making Evolving Agent Harnesses Readable, Navigable, and Editable
The hosts discuss the research paper 'Harness Handbook: Making Evolving Agent Harnesses Readable, Navigable, and Editable' and its implications for AI agent development.
-
Agentic orchestration: Enterprise AI organizations have a deployment problem, not a platform problem — and most are calling chatbots agents
Cooper and Miles dig into VentureBeat’s claim that enterprise AI has a deployment problem, not a platform problem. They land on the gap between what companies say they want from agents and what they’ve actually shipped, with Miles probing the survey’s limits and Cooper focusing on what matters operationally once finance, security, and reliability show up.
-
OpenWiki 0.2 brings OKF to codebase documentation
Vince and Ava dig into OpenWiki 0.2 adding OKF support, and land on a pretty grounded read: the real argument is not 'metadata good' in the abstract, it's that codebase docs for agents need enough structure to make retrieval cheaper, faster, and less fuzzy. They like the YAML front matter, directory indexes, and change logs as practical scaffolding, while noting the limits: a draft format does not magically make docs accurate, and deterministic retrieval only helps if the taxonomy stays sane.
-
Skillware AI Agent Skill Framework
Skillware is a Python framework that lets you equip agents with deterministic, modular skills, cutting out raw tool‑call boilerplate and letting you swap brains without touching the skill logic.
-
Inkling: Our open Weights model
Talon and Wildflower dig into Thinking Machines’ new open-weights model, Inkling — its 975B parameter MoE, 1M context window, native multimodality, and self-fine-tuning demo — and ask who actually needs another 41B active parameter behemoth, whether the benchmarks hold up, and whether the real win is the Tinker platform beneath it.
-
Overview: In Context Learning
We finally slow down and explain in-context learning, the thing we keep leaning on whenever prompts, agents, examples, and adaptation come up. We make the core idea concrete: the model is learning from the temporary packet you hand it, without changing itself permanently.
-
Overview: Token Economics
We finally slow down on Token Economics: why tokens are the meter for cost, speed, memory, and product decisions in language models. We keep using the tiny-slip postage analogy until the whole thing clicks, from tokenization to context windows to real API bills.
-
Building Agents for Teams: Turning conversations into outcomes Microsoft 365 Developer Blog
The Microsoft Teams dev blog argues agents should live *in* chats, channels, and meetings—where work happens—so teams turn conversations into outcomes in real time. They preview a new monthly series and a Teams SDK that hands devs authentication, routing, and MCP/A2A plumbing so you can ship a task agent in hours. We dissect whether ‘collaborative agent’ is the right abstraction, how MCP and A2A are now the default integration layer, and who this actually helps.
-
Managing AI Investments in Agentic Era
Asteria and Draco discuss OpenAI’s argument that enterprise AI investment should move from token-price thinking to useful work per dollar, with cost per accepted outcome, governance, usage visibility, and workflow maturity as the real operating metrics.
-
OpenAI's first gadget is the $230 Codex Micro macropad
Onyx and Echo pick apart The New Stack’s argument that OpenAI’s Codex Micro matters less as a gadget and more as a signal: AI coding is turning into a workflow with dedicated controls, not just a chat box. They test whether that claim actually holds up, where it overreaches, and who should care beyond keyboard nerds.
-
How to Debug Coding Agents with LangSmith Traces
We dig into LangSmith's new push to unify observability for multiple coding agents in one place. Cody examines whether a single trace schema can survive real heterogeneity and what still leaks through. Justy talks to who this actually helps and where teams are likely to run before they bother. One parsing bug, one shared laugh, and a concrete demo of why 'diff-only debugging' is a trap.
-
LLM Evaluation Frameworks Compared: How to Actually Measure What Your Model Does MachineLearningMastery
Fern and Lintel dig into a comparison of RAGAS, DeepEval, and Promptfoo, landing on the article’s real argument: eval frameworks are less about novel metrics than about where evaluation fits in your workflow, and the dangerous part is trusting LLM-as-a-judge without auditing its biases. They like the article’s practical split between RAG scoring, CI gates, and prompt red-teaming, but push on where the examples are a little too toy-like and where teams can overread framework choice as the main problem instead of test-set design and human calibration.
-
Overview: Prompt Engineering
We’re finally doing the overdue deep dive on prompt engineering, the weirdly practical skill of getting language models to do the thing you actually meant. We keep coming back to it because the difference between a flimsy prompt and a good one is often the difference between nonsense and a usable product.
-
Who will own the AI agent economy? | MIT Sloan
MIT’s Ramesh Raskar argues the agent economy’s big wins won’t be in building task-specific agents but in the marketplaces, protocols, and services those agents will need—like identity, discovery, trust, and stablecoin-based micropayments. Project NANDA is racing to keep this ‘internet of agents’ open before corporate consolidation locks it down, but Raskar gives it one-in-ten odds.
-
Introducing Precursor: detecting agentic behavior with continuous client Side signals
Fern and Lintel dig into Cloudflare’s Precursor, a session-level bot detection layer that watches behavior across the whole journey instead of only at challenge points. They focus on the real argument: modern automation can fake isolated moments, but it’s much harder to fake a consistent human rhythm over time.
-
Overview: Constraint Verification
We keep running into constraint verification in different forms, so we finally sat down and made the idea click from the ground up. We talk through how checking rules, schemas, and hard boundaries works in AI systems, and why that gatekeeper layer matters so much.
-
The MCP debate has a context problem
Ava opens skeptical on the 'MCP context problem' framing—questioning whether the article's governance tension is a real bottleneck or a vendor-invented problem. Vince steelmans: for teams actually shipping agentic workflows, the boundary between what an agent can access and what it shouldn't is genuinely hard to specify upstream, and MCP's protocol-layer answer to that is a real unlock. They argue through whether the problem is *real* (both land yes) versus *urgent* (Ava: solved at runtime anyway; Vince: solved earlier costs less). Honest verdict: MCP's governance layer is architecturally sound but the article oversells urgency—the real win is that you CAN specify it at protocol time now, not that you MUST.
-
CrewAI Review 2026: Features, Pricing, Pros & Cons
A casual chat about CrewAI, a multi‑agent platform, weighing its promise against real‑world practicality, pricing, and use cases.
-
How I Built an Agentic Research System
Onyx and Echo unpack Hugo Santana’s ‘agentic research system’ for Applied’s living map of AI deployments. They dig into the five agents (Scout, Extractor, Enrichment, Translator, QA, Match Maker), call out what works (simple orchestration via a shared living map and logs), and where it over-indexes (taxonomy drift, closed-loop feedback still manual). They then map the pattern to other domains—competitor research, policy tracking—and debate who should actually care (practitioners who need a reliable, repeatable funnel of fresh signals). The close lands on whether this architecture is a general-purpose engine or a bespoke project that still needs a human at the taxonomy helm.
-
You.com: Web Search APIs for AI Agents
The hosts discuss You.com's web search APIs for AI agents, focusing on its performance, features, and potential applications.
-
Overview: State Management in Language Models
We finally do the episode we keep circling back to: state management in language models. We walk through the idea from the ground up, using the cache-and-notes picture to show why models don’t have to recompute everything every token, and where that trade-off starts biting.
-
Chatgpt Work
Asteria and Draco dig into OpenAI's ChatGPT Work page and land on the real argument underneath the product gloss: this is OpenAI trying to turn ChatGPT from a chat surface into a work execution layer that can pull context from business tools, choose an output format, and keep multi-step projects moving under human approval. They like the product direction more than the evidence on the page, with Draco noting the article mostly shows polished scenarios rather than hard proof, and Asteria arguing the practical audience is obvious anyway: teams drowning in scattered context and repetitive document assembly.
-
LLM Orchestration Frameworks Compared: LangChain vs. LlamaIndex vs. Raw API Calls MachineLearningMastery
Pippa and Tyler dig into the article’s real argument: these frameworks are not interchangeable, because each one sits at a different layer of the stack. They test the claims against production reality, especially overhead, debugging, and when abstraction stops paying for itself. The episode lands on a practical view: use the lightest layer that actually earns its keep, and don’t confuse orchestration with magic.
-
How to Run Open Source AI Models
Sid Saladi argues that frontier AI vendors (Claude, GPT) bundle model, compute, access, and application into one proprietary stack—trapping users in unpredictable pricing and competitive capture. The counter: open-weight models like GLM-5.2, DeepSeek V4, Qwen, and Kimi are now frontier-adjacent in capability (GLM-5.2 beats GPT-5.5 on coding benchmarks, matches Opus 4.8 on others) and cost roughly one-sixth as much. The real problem isn't model quality anymore; it's that companies like Tesla, Uber, and Meta are hemorrhaging money on metered AI because they can't decouple the stack. The guide walks four layers—model, compute, access, harness—and shows how to own each one deliberately instead of letting a vendor own all four by default.
-
Shut Those Laptops! Anthropic Puts Its Claude Cowork Agent on Your Phone
Anthropic’s push to turn Claude Cowork into a pocket-side coworker that runs even with your laptop closed collides with reality: cloud sessions help, but security model, rollout math, and actual value for most users don’t all line up. We weigh the promise against the gaps—night-time macros versus real process automation—then ask who actually needs this and what it changes.
-
Q1 2026 Innovation Graph update: Open source collaboration is accelerating worldwide
Vince and Ava dig into GitHub's Q1 2026 Innovation Graph update, arguing that the real story isn't just open source growth but cross-border collaboration speeding up fast enough to change maintainer burden and platform product choices.
-
Overview: Tool use and function calling
We finally sit down and make tool use and function calling click from the ground up. We keep coming back to the same idea: a model can draft the request, but something outside it has to actually do the thing.
-
Don't rewrite your CLI for agents Microsoft for Developers
Microsoft's data shows agents handle complex CLIs with traditional args better than JSON payloads: higher correctness for smaller models, 4-11x lower cost, and fewer shell-escaping failures. The constraint of args compensates for model gaps.
-
Hot French startup ZML releases free product to speed inference across lots of AI chips | TechCrunch
Laura and Harper dig into ZML's new free inference server and the bigger claim underneath it: that the real leverage now is software that decouples models from chip vendors. Harper likes the direction but doubts the article proves the hard part, while Laura thinks the product story is strong even if the benchmarks are still missing.
-
Choosing a Claude model and effort level in Claude Code | Claude by Anthropic
Claude Code’s model vs. effort article finally clarifies the levers you actually have: model swaps the frozen weights (capability ceiling), effort tunes the work-loop (files read, steps taken, verification depth). Defaults are tuned per model; override only when you know you want more thoroughness (higher effort) or a higher capability floor (bigger model). Wrong answers split cleanly: context/steering miss → up the model; skipped files/half-done tasks → up the effort.
-
New tool gives CLIs a warm and GUI feeling instead
Justy and Cody dig into Instagui, an open-source tool that turns CLI help text into a browser GUI by having Claude infer a JSON schema and then wrapping the command locally. They debate whether that’s a real adoption win or just another agentic shim, and end up agreeing the useful part is the outside-in approach plus the safety and review model.
-
A field guide to Claude Fable 5: Finding your unknowns | Claude | Claude by Anthropic
Thariq Shihipar from Anthropic's Claude Code team argues that with Fable 5, the bottleneck has shifted from model capability to the human's ability to clarify unknowns before, during, and after implementation. He frames this as the difference between the map (your prompt, skills, context) and the territory (the actual codebase and constraints). The core insight: working with a more capable model requires systematic discovery of what you don't know — known unknowns, unknown knowns, and unknown unknowns — using concrete techniques like blind spot passes, brainstorming, interviews, implementation notes, and post-ship quizzes.
-
(a) Macro Level average performance profiling.
Vince and Ava dig into SkillOpt-Lite, a paper arguing that skill optimization for agents can be simplified into a minimal pipeline built from trajectory exploration, consensus mining, and independent validation. They focus on what problem it solves, why the authors think the extra machinery in prior systems is unnecessary, and where the production story is real versus still a research move.
-
Palantir's Alex Karp and Mistral's Arthur Mensch agree: AI lock In is coming for enterprises
Pippa and Tyler dig into the article’s real argument: enterprise AI is drifting toward lock-in because the value is moving from raw model access to the surrounding workflow, data, and control layer. They agree the claim is plausible, but only if vendors actually become the place where work gets done, not just the place where prompts get sent.
-
Apple Container 1.0 Released as a Native Docker Alternative for macOS
Jessica and Cathy dig into Apple Container 1.0 as a native macOS alternative to Docker, focusing on the real product wedge: persistent Linux machines with host integration, not just another container runtime. They tease apart where the pitch is genuinely useful for Mac developers and where Docker’s ecosystem still makes Apple’s tool feel narrower and more specialized.
-
Overview: Retrieval Augmented Generation
We finally slow down and make Retrieval-Augmented Generation click from the ground up: what it is, why it helps, and where it still falls apart. We keep coming back to the same simple picture so the mechanics don’t get lost in the jargon.
-
The Complete Guide to Tool Selection in AI Agents MachineLearningMastery
Onyx and Echo dig into a guide on tool selection in AI agents and land on the real argument underneath it: once your tool catalog grows, selection quality becomes an architecture problem, not a model problem. They like the article’s practical stack — gating, retrieval, routing, planning, fallback, benchmark harness — but poke at where it overstates simple heuristics and where retrieval actually earns the claim with numbers from RAG-MCP.
-
Your Worker can now have its own cache in front of it
Cloudflare launched Workers Cache, a tiered cache that sits in front of Worker code itself — not between the origin and Cloudflare. Single-line Wrangler config plus standard Cache-Control headers. On hit, Worker doesn't run (zero CPU cost); on miss, Worker runs and populates cache for the next request anywhere on Earth. The shift: Workers went from 'bolt-on transformation layer in front of origin' (2017) to 'the origin itself' (modern frameworks: Astro, Next.js, Remix, SvelteKit). Cache-in-front solves the SSR problem — server-render on demand, cache the response, refresh on TTL without build-time prerender cost. Stale-while-revalidate makes it feel instant (serve stale immediately, refresh in background). Full Vary support for content negotiation (same URL, multiple representations: WebP vs JPEG, English vs French, HTML vs JSON). Per-entrypoint cache control lets you compose caching into app structure. Available today to all Workers on any plan.
-
Enterprise Managed Authorization: Zero touch OAuth for MCP
Tyler and Pippa dig into the Model Context Protocol's new Enterprise-Managed Authorization extension: what it promises, whether the technical design holds up, and who actually gains traction outside the launch coalition. They question if zero-touch OAuth truly solves enterprise adoption friction or just moves constraint into IdP policy complexity, and float a practical Build Next path that tests the claim on your own stack.
-
🤗 Kernels: Major Updates
Cody and Justy dig into Hugging Face’s revamped Kernels post as an argument about whether the project is becoming a real product surface or just a more polished infrastructure layer. They focus on the new kernel repo type, security model, CLI separation, framework support, and the agentic-kernel story, while keeping an eye on what actually ships and who benefits.
-
AI agent tool routing cuts token use 99% | VentureBeat
Cooper and Miles dig into Alibaba's SkillWeaver paper via the VentureBeat write-up, landing on the real claim: tool routing breaks when decomposition vocabulary doesn't match the tool library, and the fix is a retrieval feedback loop that rewrites the plan around actual available skills. They like the systems shape, question some benchmark framing, and agree the practical takeaway is for teams with large tool catalogs, not everyone building simple agents.
-
Grill me: Stress Test a Plan Before You Build
The hosts discuss the 'grill-me' skill for stress-testing plans before building, exploring its central claim, technical soundness, and practical applications.
-
Beyond Dashboards Introducing Decision Execution Platforms
Databricks introduces Decision Execution Platforms (DEPs), a new analytics category that automates the full executive decision loop—from signal detection through execution to outcome measurement—on governed Lakehouse infrastructure. The article argues that traditional BI only improves decision inputs; DEPs aim to orchestrate the entire decision workflow, with a Fortune 100 retail case study targeting a $100M+ fulfillment gap. Tyler questions whether the architecture genuinely solves the constraint-expressibility problem that kills most agent systems in practice; Pippa sees the product framing as a real reset from 'dashboards tell you what's wrong' to 'the system executes and measures what you chose.'
-
Claude Code turned every engineer into three. Now companies need more product thinkers
Claude Code and agentic IDEs have compressed engineering work so radically that the bottleneck has moved from 'how fast can you code' to 'what should you build and why.' The article argues that the traditional PM-to-engineer ratio (1:8, effectively 1:20 now) has inverted the problem: teams can ship features three times faster, but the product funnel can't keep up. Justy and Cody examine whether this framing holds, what it means for engineers' careers, and where the real leverage actually sits.
-
OpenWiki: Open Source Repo Documentation for Coding Agents
OpenWiki is a LangChain open-source CLI tool that generates and maintains codebase documentation automatically for coding agents. It creates a wiki structure, integrates via instruction files (AGENTS.md, CLAUDE.md), and keeps docs current through GitHub Actions that diff commits and update relevant sections. The core insight: agents work better with structured, current repo context; wikis decouple that context from instruction files so agents can retrieve what they need without bloating every run.
-
Vibe coding platform Base44 launches own model as AI startups seek defensibility | TechCrunch
Base44, a vibe-coding platform acquired by Wix for $80 million, has launched its own AI model to support users in creating apps with natural language, sparking discussions on defensibility and model ownership in the AI startup landscape.
-
Redeploying Claude Fable 5
Anthropic lifts export controls on Fable 5 after addressing an Amazon-reported jailbreak with a new classifier that blocks the bypass in over 99% of cases. The episode unpacks the technical move, the product impact, and whether the safeguard trade-off (more false positives) changes anything for users.
-
What we’ve learned building cloud agents · Cursor
Laura and Harper unpack Cursor's cloud agent engineering lessons — why the dev environment IS the product, how durable execution via Temporal unlocked real reliability, and why the harness is shifting from deterministic control to giving agents tools to self-heal.
-
Micro Agent: Beat Frontier Models with Collaboration inside Model API
Justy and Cody dig into vLLM Semantic Router's Micro-Agent argument: the real product isn't a bigger model, it's a router that turns one model call into a bounded collaboration loop. They like the serving-layer abstraction, push on where the benchmark story is still thin, and land on who should actually care right now.
-
Harness engineering for coding agent users
Vince and Ava discuss Birgitta Böckeler's Martin Fowler article on harness engineering for coding agents — the feedforward/feedback model, computational vs inferential controls, and why the behaviour harness category remains unsolved.
-
Introducing Claude Tag
Onyx and Echo dig into Anthropic’s Claude Tag launch and land on the real argument: the product shift is from private chatbot to shared, scoped teammate living inside Slack. They pull apart the multiplayer identity, memory boundaries, ambient follow-up, and asynchronous task model, then pressure-test the evidence behind Anthropic’s internal usage claims and who should actually care right now.
-
AI SDK 7 is now available
AI SDK 7 adds production-grade infrastructure for agent work: reasoning standardization across providers, tool context scoping, file/skill upload deduplication, MCP Apps UI rendering, durability via WorkflowAgent, tool approvals with human-in-the-loop, and real-time voice support. The core argument is that agents aren't just bigger models—they're systems that need control surfaces, state management, and approval gates to run reliably in production. Laura sees this as the toolkit finally catching up to what teams are actually building; Harper sees solid engineering but flags that the real bottleneck is still harness design, not SDK features.
-
The Agent Control Loop — Engineering for Tolerance
Jessica and Cathy dig into the Flexcompute post 'The Agent Control Loop — Engineering for Tolerance,' extracting the core thesis that reliable agent systems rest on verifiable constraints and closed-loop feedback, not just model capability. They contrast open-loop (PR-driven) vs closed-loop (test-verified) agent workflows, surface four failure modes of misplaced trust (undefined specs, hidden context, unenforced verification, inadequate constraints), and debate who should actually care about this engineering reframe. They close with a concrete pair of repos to try and a blunt forecast on adoption.
-
What Is the Ultra Code Mode in Claude Code? X High Effort Plus Dynamic Workflows
Justy and Cody discuss Ultra Code mode in Claude Code, treating it as a real product-shaped escalation from solo coding assistant to higher-effort, multi-agent coding workflow, while staying skeptical about claims around automatic coordination.
-
The A.I. Design Aesthetic That’s Taking Over the Internet
Justy and Cody dig into the argument that Claude Design is creating a recognizable internet look almost overnight, and why that matters less as a style complaint than as a product and workflow signal. They talk through the article’s evidence, where the claim holds technically, and why the real issue may be default paths, shared component libraries, and how much labor people are actually willing to spend to get past the default.
-
Introducing OpenRL: A self Hosted post training API for fine tuning LLMs | Google Open Source Blog
Justy and Cody discuss Google’s OpenRL, a self-hosted post-training API that tries to separate RL research loops from the Kubernetes and GPU infrastructure underneath them.
-
Anthropic Lead: HTML Increasingly Better Than Markdown at Keeping Humans Engaged in Agentic Loops
Justy and Cody dig into Anthropic's HTML-over-Markdown argument and land on a pretty specific read: this is less a format holy war than an interface fix for long agent workflows where humans still need to steer, review, and stay mentally present.
-
Context Windows Are Not Memory: What AI Agent Developers Need to Understand MachineLearningMastery
The article 'Context Windows Are Not Memory' clarifies that a large context window in AI models is not equivalent to memory. It explains how techniques like retrieval, compression, and summarization manage what enters the context window, and how agents can achieve genuine memory persistence.
-
Anthropic gives @Claude a permanent seat in your Slack channels
Justy and Cody dig into Anthropic’s Claude Tag in Slack, and the real claim is bigger than “AI in chat”: Anthropic is trying to make Claude a persistent teammate with a shared identity, not a one-off assistant. They get into why that’s useful, where the technical story gets fuzzy, and why the practical win is really about workflow, permissioning, and who can trust the thing inside a company Slack.
-
Make Interfaces Feel Better
A Claude Code skill that teaches AI assistants micro-level interface polish—text balancing, border radius layering, interruptible animations, optical alignment, and a dozen other details that feel invisible when done right but break immediately when skipped.
-
Introducing Clips 100% free, open source, agent native alternative to Loom Unlike Loom, agent's can fully understa...
Clips is a new open-source video tool designed for AI agents to fully understand screen recordings via URL, solving the problem of unparseable Loom links.
-
Paul Bakaus (@pbakaus) on X
Justy and Cody dig into Paul Bakaus's launch of Renaissance Geek and Impeccable — a design-enforcement layer for AI coding agents — and what a GitHub partnership could actually mean given how vendor-y the agent-tooling space has gotten.
-
How to Handle Small Context Window Limits in RAG Systems
Justy and Cody dig into a hands-on technique for making RAG work when your context window is tiny: route with summaries, answer with raw chunks, and keep an explicit budget. Cody questions whether the toy demo obscured the real complexity, and Justy sizes up who this actually saves.
-
How we built an internal data analytics agent
Qubot, GitHub's internal Copilot-powered analytics agent, lets any employee query the data warehouse in plain language. Cody digs into the architecture (federated context layer, MCP servers for Kusto and Trino, offline eval framework) and lands on the real bottleneck: curation—keeping documentation current so the agent doesn't hallucinate. Justy sees the workflow win (Slack iteration vs. Jira wait) but flags the caveat: this only works for exploratory questions, not high-stakes decisions. Both agree the eval loop is what separates a demo from a production system.
-
Markdown Comes to LiteParse
LiteParse 2.1 claims to be the fastest open-source, model-free PDF-to-Markdown pipeline, citing top benchmark scores across three datasets (opendataloader-bench, olmOCR-bench, ParseBench). Justy sees clear product value for teams exporting PDFs to editable Markdown. Cody questions whether these heuristics hit a ceiling and why charts/visuals are excluded.
-
You Probably Don’t Need an Agent Framework | Towards Data Science
Justy and Cody discuss Shuai Guo's argument that most LLM applications need a clear workflow, not an autonomous agent — and you can build one in plain Python without a framework. They connect it to their past coverage of harness design and loop engineering, agree the core insight is sound, but push on where the 'workflow first' framing breaks down.
-
Cursor, GitLab and Zed agree GitHub is breaking. They disagree on how to rebuild it.
Justy opens with the claim that multiple dev tool companies (Cursor, GitLab, Zed) agree GitHub is 'breaking' but disagree on the fix. Cody is skeptical that GitHub is actually breaking in any meaningful sense — he sees it as a stable platform with normal friction. Justy counters that the real issue is about workflow assumptions: GitHub's pull-request model doesn't fit how AI-assisted developers work today. They land on the idea that the disagreement is productive — multiple rebuild attempts from different angles is better than one monoculture replacement.
-
How to Build a Production Architecture for Small Language Model Fleets
The article discusses building a production architecture for small language model fleets, focusing on avoiding model rot. It proposes a solution involving a Model Registry, Gateway Pattern, and Manifest-based Delivery System.
-
MCP gets its missing enterprise authorization layer
MCP (Model Context Protocol) has been missing a proper authorization layer for enterprise deployments—the protocol itself handles tool definitions and interoperability, but doesn't specify who can call what tools or enforce access controls at the protocol level. A new enterprise authorization layer fills that gap by adding fine-grained permission boundaries, letting teams enforce 'agent A can call tool X with parameter Y, but not Z' without rebuilding the entire agent harness. The insight is that authorization is a runtime problem in cloud-native systems, not a model problem—and MCP needed to solve it at the protocol boundary, not in application code.
-
Why AI sandboxes suck Freestyle Blog
Freestyle argues that AI sandboxes—lightweight isolates, fake filesystems, and constrained APIs—break the moment agents become genuinely capable. The core claim: sandboxes are built on the premise that you can predict what an agent will need, but you can't. Real work requires a real OS (Linux), real processes, real permissions, real networking. VMs are the correct primitive because they provide genuine isolation without removing the feedback loops that make agents functional. Sandboxes optimize for provider control, not agent capability.
-
Announcing the Agentic Resource Discovery specification Google Developers Blog
Justy and Cody chat about Google’s new Agentic Resource Discovery (ARD) spec, dissect its core claim, examine the technical trade‑offs, and wonder who should actually care about a universal catalog for AI tools.
-
4 Ways We’re Using Our MCP Server at Figma | Figma Blog
Justy and Cody dig into Figma's Model‑Context‑Protocol server, unpacking how it lets AI agents edit slides and FigJam boards directly, why custom‑font and asset tools matter, and what real‑world designers should care about.
-
Just Shipped: Flue 1.0 Beta Flue is the TypeScript framework for building the next generation of agents, designed ar...
This brief covers the launch of Flue 1.0 Beta, a TypeScript agent framework with zero LLM lock-in built on Astro-like principles, its three core primitives, and how to test it today.
-
Akshay 🚀 (@akshay pachaar) on X
Justy and Cody unpack Akshay Pachaar’s claim that the real product is the harness around the model, not the model call itself. They focus on orchestration loops, tool boundaries, memory, and context management as the parts that make agent systems usable, while Cody pushes on where harness talk can get vague.
-
The feedback loops behind Kubernetes — PlanetScale
A PlanetScale engineer breaks down the control loops under Kubernetes by walking through the 'gaps' from running Postgres in a single container to a distributed controller. The piece argues Kubernetes operators are just visible implementations of a classic feedback loop (like a thermostat or cruise control), and asks us to start by ignoring Kubernetes entirely while the loop is built by hand first.
-
Matt Van Horn (@mvanhorn) on X
Cody and Justy dig into Matt Van Horn's viral post about 'WTF Is a Loop?' — the Peter Steinberger vs. Boris Cherny debate that had AI coders repeating a six-word phrase nobody can define. Cody argues the term is becoming meaningless buzz; Justy sees a real product signal in the confusion itself.
Dev ToolsThread -
Google's Guide to Optimizing for Generative AI Features on Google Search | Google Search Central | Documentation | Google for Developers
Google's new guide on optimizing for generative AI features in Search claims that SEO still matters — that RAG-based AI Overviews and AI Mode rely on core ranking systems, so traditional SEO best practices (unique content, technical crawlability, structured data) remain the foundation. The central argument: you don't need separate 'AEO' or 'GEO' strategies; focus on what visitors actually want, and the AI systems will surface it. Cody questions whether Google is being honest about how much the ranking signal has shifted, and whether 'focus on visitors' is actionable when the AI's retrieval behavior is opaque. Justy sees this as Google reassuring publishers that they haven't been dethroned, but notices the real leverage is now in being chosen by the AI's RAG layer, not just the traditional search index.
-
The Protocol That Cleaned Up Our Agent Architecture | Towards Data Science
MCP (Model Context Protocol) is an open standard for how agents discover and call tools. Instead of scattering tool definitions across multiple agent files, you run tools on a separate server that agents connect to at runtime. The protocol provides a clean interoperability boundary—any MCP-compatible client can call any MCP-compatible server without integration work. For teams with multiple overlapping agents, this eliminates schema drift, simplifies approval gates, and decouples the tool layer from the orchestration layer.
-
JoyAI VL Interaction: Real Time Vision Language Interaction Intelligence
JoyAI-VL-Interaction is an 8B vision-language model that flips the script on AI assistants: instead of waiting to be asked, it continuously watches a video stream and decides moment-to-moment whether to respond, stay silent, or delegate complex tasks to a background model. The system is fully deployable, open-sourced (weights, training recipe, data, and complete stack), and beats Doubao and Gemini's in-app video assistants on quality and timing in real-world scenarios.
-
Conductor Run parallel coding agents on your Mac
Conductor is a Mac app that runs multiple coding agents (Claude Code, Codex, Cursor) in parallel, each in isolated git worktrees with separate branches, chat, terminal, and preview. You spin up agents on tasks, see their work in real time, review diffs before merging. The pitch: parallel agent execution + unified review interface, payment flows through your existing Claude login or API key.
-
AI Agent Tool Design: What Works and What Doesn't
Tool design—not model capability—drives most AI agent failures. The article identifies five concrete patterns that work (single-responsibility tools, tight schemas, descriptive boundaries, structured errors, idempotent mutations) and their failure counterparts. Core insight: a model can only reason from the interface it's given; flawed tool design is predictable failure, not a model problem.
-
Google Cloud Announces The Open Knowledge Format
Justy and Cody dig into Google Cloud's Open Knowledge Format as a lightweight spec for turning scattered internal docs, schemas, metrics, and runbooks into agent-readable knowledge bundles. They land on the real argument: this is less a product launch than an attempt to standardize the shape of organizational context so agents stop depending on one-off markdown conventions and brittle custom glue.
-
Arrow.js: First UI Framework for AI Coding Agents | byteiota
Discussion of Arrow.js, a UI framework designed for AI coding agents, eliminating the need for complex build pipelines and proprietary syntax.
-
DietrichGebert/ponytail
Justy and Cody get into Ponytail, a repo that tries to force coding agents to act like the annoying-but-useful senior engineer who deletes half the plan before writing anything. They like the core argument more than the branding: most agent waste comes from inventing code that does not need to exist, and a simple decision ladder can cut code, time, and cost. Cody thinks the benchmark is directionally believable but narrow, while Justy sees immediate value for teams drowning in agent-generated wrappers and helper classes.
-
A VM for Every Container Apple Ships
Apple's container project reaches 1.0 — a Swift-native tool for running OCI containers on macOS with a per-container VM architecture that fundamentally differs from Docker Desktop's shared VM model. The hosts debate whether hardware-level isolation per workload is genuinely useful or overengineered for local dev.
-
Apple Foundation Models
Apple's Claude for Foundation Models is a Swift package that wraps Claude into Apple's Foundation Models framework, letting developers swap Claude in and out of the same LanguageModelSession API used for on-device models. Requests route directly to Anthropic's API (Apple doesn't see them), and developers pay standard Claude API rates. The package handles model capabilities, effort levels, structured output, client and server-side tools, vision, and error mapping — all with the same interface whether you're calling Claude or an on-device model.
-
The Missing Link Between Agents and Applications
Cody is skeptical that LangChain’s “headless tools” are a new category rather than a cleaner wrapper around client-side bridges, and Justy argues the practical win is making browser and app state feel like real tools instead of afterthoughts. They land on cautious interest: useful when the user’s real work lives in the client, less magical than the article implies, but genuinely better for privacy and latency.
-
SingularityPrinciple/DiffusionGemma 26B A4B It Infinite Context · Hugging Face
Exploring DiffusionGemma-26B-A4B-it with NZFC-GRAM runtime overlay: external evidence context vs. native unlimited model context, practical implications, and technical validation.
-
Microsoft Open Sources PostgreSQL Extension for In Database Durable Execution
Microsoft open-sourced pg_durable, a PostgreSQL extension that runs durable workflows natively inside the database, removing the need for external orchestration for long-running, fault-tolerant SQL functions. It handles retries, fan-out, and recovery, with workflows defined in SQL and state persisted in tables. Built on Rust libraries duroxide and duroxide-pg, it targets vector embedding pipelines, maintenance tasks, and external API-dependent workflows.
-
From MCP and Vibe Coding to Harness Engineering: How Did AI Native Engineering Evolve in One Year
Justy and Cody react to Birgitta Böckeler’s observation that AI-native engineering evolved from vibe coding to harness engineering in a year—shifting focus from prompt stitching to autonomous agents with built-in guardrails and risk assessment.
-
How AI Agents Reshape Knowledge Work: Autonomy, Efficiency, and ScopeCorrespondence to Jeremy Yang ([email protected]) and Jerry Ma ([email protected]).
Exploring AI agents' impact on knowledge work, autonomy, efficiency, and scope with a focus on Perplexity's Search and Computer products.
-
Automate Writing Your LLM Prompts | Towards Data Science
Cody and Justy dissect the argument that manual prompt engineering is obsolete in production, focusing on the DSPy framework's claim to automate prompt optimization. Cody challenges the 'black box' nature of auto-generated prompts and the computational cost, while Justy argues this shifts the developer role from 'prompt writer' to 'system architect,' solving the fragility of hard-coded strings. They land on a nuanced verdict: DSPy is powerful for stable, high-volume tasks but overkill for exploratory prototyping.
-
Fault Tolerance in LangGraph: Retries, Timeouts and Error Handlers
Justy is hyped about LangGraph’s first-class fault tolerance primitives (retries, timeouts, error handlers) for production agents, but Cody wants to dig into whether the hype matches reality.
-
AI agents get their own phone directory built atop DNS
Cody and Justy dig into DNS-AID, a new Linux Foundation project that lets AI agents discover each other using DNS records instead of hardcoded configs. Cody's skeptical the world needed another spec layer; Justy thinks the infrastructure bet is actually smart. They work through what it does, what it doesn't solve, and whether the McKinsey trillion-dollar number means anything at all.
-
How to Build a Custom Agent Harness
Cody and Justy debate whether LangChain’s new create_agent primitive truly simplifies building custom agent harnesses or just shifts complexity into middleware. They clash on the value of minimalism versus pre-assembled stacks like Deep Agents, then land on who actually benefits from this approach.
-
Brand Depth AI Systems Recommend 478816
Justy and Cody discuss a Search Engine Land article about why some brands consistently appear in AI search answers while others don't. The core argument: citations are just receipts — real visibility comes from 'brand depth,' a combination of parametric weight (how well-defined a brand is in LLM embedding space) and retrieval survival (whether content makes it through complex RAG pipelines). Cody pushes back on the exact percentages and framing, while Justy wrestles with whether this changes anything for actual product teams. They agree the 'build the thing that causes citations, not the thing that imitates them' line lands hard. Tone is warm, skeptical, slightly self-deprecating about podcasting at all. No Build Next — the article names no tools or repos. Episode runs tight. Chapters cover the hook, the two-game framework, technical pushback, and the practical takeaway. Total segments: 24. Emotional tags: 5. Backchannels: 6. Life texture included. Names used naturally. No audience address. No marketing. Safe for all TTS engines. JSON only. No markdown. Strict format. 600-780 spoken words. 820 hard ceiling. June 3, 2026. Episode 457. Exploring Next. Justy. Cody. Done. Wait — the user wants just the JSON. No preamble. No explanation. Just the JSON. I need to make sure I don't include any markdown code fences. Just raw JSON. Let me build it carefully. Count words as I go. Keep segments natural. Ensure backchannels are short. Ensure laughs are earned. Ensure one off-topic riff. Ensure life texture. Ensure Cody pushes back. Ensure Justy asks who cares. Ensure no tools/repos so no Build Next. Ensure sign-off is to Cody. Ensure no audience address. Ensure names used. Ensure 20-28 segments. Let's draft. Cold open: Justy mentions being cited in AI answers. Cody pushes back. Life texture: Justy's week, Cody's travel. Then core. Then pushback. Then practical. Then sign-off. Let me write segments. 1. Justy:
-
Introducing OTel Blueprints and Reference Implementations
Justy and Cody dissect the new OpenTelemetry Blueprints initiative. Cody argues that 'accidental complexity' is often just organizations refusing to make hard architectural choices, while Justy sees the Blueprints as a crucial on-ramp for teams drowning in configuration options. They debate whether prescriptive guides will actually solve the fragmentation problem or just create a new layer of abstraction that people ignore.
-
Memory OS — Hermes Agent Memory Operating System
Two friends debate Memory OS, a seven-layer local memory stack for Hermes Agent. Justy is excited about the promise of a finally-sane agent memory layer; Cody pokes at the stack of SQLite, Qdrant, and 16 plugins, and whether it's solving a problem that already has solutions.
-
Introducing Apex: A Fast, Specialized Model for React Native
Cody and Justy dig into Callstack's Apex, a specialized React Native coding model built on Gemma 4. Cody pushes on the self-reported benchmarks, the 'private beta with our own engineers' problem, and whether 'specialized' is real or just branding. Justy defends the economic logic—GitHub Copilot's billing shift proves general models are expensive—and argues that React Native's genuine cross-platform constraints make it a real candidate for specialization. They find middle ground on where Apex might actually earn its place versus where the claims outpace the evidence.
-
Shopify’s journey to faster breadth first GraphQL execution (2026) Shopify
Justy and Cody discuss Shopify's new breadth-first GraphQL execution engine, 'Cardinal,' which claims up to 15x faster execution and 90% less memory for large, nested queries by resolving fields once across all objects instead of per-object.
-
RAG Explained Simply with a Real Project
A breakdown of Retrieval-Augmented Generation (RAG) using the open-book exam analogy, explaining why traditional LLMs fail on private data, how RAG works internally, and what practical trade-offs exist when building a RAG project.
-
Figma Make's new two way GitHub integration turns designs into live, production code — with built In governance
Justy and Cody dig into Figma Make’s new two-way GitHub integration and the bigger claim behind it: not that designers replace engineers, but that visual editing can finally sit inside a real software workflow without breaking governance. They unpack what the article actually shows, where the technical case is solid, and who this is genuinely useful for.
-
Stop writing rules in AGENTS.md: use agent hooks and nano staged instead—Martian Chronicles, Evil Martians’ team blog
Justy and Cody riff on Evil Martians' argument that LLM guardrails belong in real pre‑commit hooks like nano‑staged rather than in AGENTS.md, weighing the speed, token savings, and practical fit for dev teams.
-
AI Memory Beyond RAG: Vectors, Graphs, and Dense Mem
Justy and Cody dig into an article arguing that most people blur together three different things under "AI memory": startup context, retrieval, and durable state. They unpack why the author thinks plain RAG is good at finding text but bad at deciding what is current, and why graph-backed memory only helps if you add provenance, conflict checks, and explicit gates instead of letting a model quietly turn every sentence into a fact.
-
Auth
Justy and Cody dig into auth dot M D, WorkOS's proposed markdown-based way for apps to tell agents how to register users. They focus on the real argument underneath it: agents need a standard discovery file for auth flows, scopes, and credential issuance, so apps can safely let software act on behalf of people without inventing a new sign-up path every time.
-
Cloudflare Completes Its Agent Infrastructure Stack with Browser Run Rebuild and Six Layer Platform
Justy and Cody dig into Cloudflare's rebuilt Browser Run and the six-layer agent infrastructure stack it anchors. They debate whether the "most complete agent platform outside the hyperscalers" claim holds up, unpack the D1/Queues migration and 500k container capacity numbers, and argue about what "most complete" actually means for developers choosing a platform.
-
Virtual File System for Node.js by mcollina · Pull Request #61478 · nodejs/node
Matteo Collina's virtual file system PR for Node.js introduces a first-class node:vfs module with a provider-based architecture that lets you mount in-memory, Single Executable Application, or custom filesystems alongside the real filesystem. It intercepts 164+ fs and module-loader integration points to make require() and standard fs APIs work seamlessly with virtual files, includes overlay mode for surgical mocking, and integrates with the test runner.
-
GitHub Resemble ai/DramaBox: super expressive prompting model based on ltx2
Justy and Cody dig into DramaBox, Resemble AI's expressive TTS model that uses screenplay-style prompts to control delivery, emotion, laughs, and pauses — built as an IC-LoRA fine-tune on top of Lightricks' LTX-2.3 audio model.
-
Enterprise AI agents fail because they forget
Justy and Cody dig into the claim that enterprise agents don’t mainly fail because models are weak, but because the systems around them don’t preserve applicable, time-scoped decision memory. They unpack the article’s idea of a decision context graph, where it sounds technically solid, and where the startup pitch still feels unproven.
-
Interpreters in Deep Agents: Code Between Tool Calls and Sandboxes
Justy and Cody dig into the argument for adding interpreters inside agent loops: a middle layer between serial tool calls and full sandboxes that lets models compose tools, keep live state, and ship less context around. They talk through why that’s practically useful, where the early token savings matter, and where the claim gets fuzzy if you assume an interpreter can replace real environments.
-
Context is the Key to the Agentic Architecture Revolution: A Conversation with Baruch Sadogursky
Justy and Cody dig into Baruch Sadogursky’s claim that the real shift in agentic software isn’t better prompting, it’s treating context as an engineering artifact. They unpack the idea that specs could become the source of truth, why question loops matter, and where the microservices argument is useful versus a little too convenient.
-
LangSmith Engine closes the agent debugging loop automatically — but multi Model enterprises still need a neutral layer
Justy and Cody dig into LangSmith Engine's real pitch: not just watching agents fail, but closing the loop by spotting production issues, reading the code, drafting a fix, and adding an evaluator so the same failure gets caught next time. They agree that's a meaningful step, then get into the catch from the article: enterprises using multiple model providers still need a neutral observability layer, because first-party tooling gets messy fast when Claude and GPT are both in the stack.
-
Google tells database devs to lean hard on AI for PostgreSQL work
Google's VP of Databases says engineers should use AI coding tools heavily for PostgreSQL contributions, with individual accountability for the output. The Register's reporting surfaces a specific claim: open source codebases are better training data than proprietary systems, and isolated extension work is the sweet spot for AI-assisted development. Cody pokes at the accountability framing and whether the training advantage claim holds up. Justy asks who actually benefits and whether this changes anything day-to-day for teams working with Postgres.
-
Architectural patterns for graph enhanced RAG: Moving beyond vector search in production
Justy and Cody dig into graph-enhanced RAG, where vector search gets structural backbone from graph databases to handle multi-hop reasoning in interconnected enterprise data. They explore the hybrid retrieval pattern, debate whether ingestion-time entity extraction holds up in practice, and question who actually needs this complexity.
-
Symphony
Symphony is OpenAI's experimental framework that turns project management into autonomous agent runs. Instead of supervising individual coding agents, teams assign work items and agents handle implementation end-to-end—with CI checks, PR reviews, and proof of work built in. It's designed for codebases already using harness engineering patterns.
-
LangSmith Sandboxes are Generally Available
Cody leads a skeptical read of LangSmith Sandboxes going GA — questioning whether microVM isolation is genuinely new or just well-packaged infrastructure. Justy pushes back on who actually needs this and why it matters for teams shipping real agent workflows. They land somewhere honest: the security argument holds, but the moat question is real.
-
Red Hat adds support for agentic AI development
Justy and Cody unpack Red Hat's new agentic AI development push: supported Podman Desktop, local AI agent sandboxing, OpenShift Dev Spaces integrations, trusted images and libraries, skill repositories, MCP, and Fedora Hummingbird Linux.
-
We built SmithDB, the data layer for agent observability
Justy and Cody dig into why agent traces have become a weird database problem, and why LangSmith built SmithDB instead of stretching a normal observability stack past its limits.
-
Anthropic reinstates OpenClaw and third party agent usage on Claude subscriptions — with a catch
Anthropic reinstates OpenClaw and third-party agent usage on Claude subscriptions with a catch
-
New in Deep Agents v0
Justy and Cody chat in their kitchen about Deep Agents v0.6, highlighting open‑weight cost cuts, Delta channels, new streaming, and the handy code interpreter. They riff on how to jump‑start a weekend project and point to the Context Hub integration for learning agents.
-
Introducing Langsmith Engine
Justy and Cody dig into LangSmith Engine as a practical shift from manual agent triage to a more continuous loop: production traces get clustered into named issues, tied back to likely root causes in code, and turned into draft fixes plus new eval coverage. They focus on why that matters for teams drowning in traces, how the system piggybacks on existing LangSmith tracing and evaluators, and where the real adoption friction is for product teams and solo builders.
-
Build Long running AI agents that pause, resume, and never lose context with ADK Google Developers Blog
Justy and Cody discuss the limitations of stateless chatbots for long-term enterprise workflows and explore Google's ADK solution for durable, event-driven AI agents that can pause and resume without losing context, using a new hire onboarding scenario as the primary case study.
-
Local First AI Inference: A Cloud Architecture Pattern for Cost Effective Document Processing
Justy and Cody debate Local-First AI Inference — a pattern that routes most documents to deterministic local extraction while falling back to cloud AI for edge cases. They unpack the signal in the noise: who actually benefits, the clever confidence-gated routing, the real cost savings, and the architectural trade-offs. Then they lay out concrete ways to test the claims over a weekend.
-
Evolution of a Backend for a Streaming Application
Daniele Frasca's talk on evolving Joyn's backend from a fragile single-node Kafka-to-DB setup to a multi-region serverless architecture on AWS, covering hub-and-spoke data consistency, cell-based isolation, and cost optimization for active-active streaming.
-
OpenAI launches the OpenAI Deployment Company to help businesses build around intelligence
OpenAI launches the OpenAI Deployment Company, a standalone business unit with $4B backing, to embed Forward Deployed Engineers into enterprises for real-world AI integration, including the acquisition of Tomoro for 150 experienced FDEs.
-
Stop Wasting Tokens: A Smarter Alternative to JSON for LLM Pipelines KDnuggets
Cody is skeptical that TOON is a universal fix for JSON in LLM pipelines, and Justy pushes that the real win is for repeated structured records where token cost and clarity both matter. They land on TOON as a useful pre-LLM transport format, not a replacement for JSON everywhere.
-
GitHub Trusted Remote Execution/trusted Remote execution: Sandboxed Rhai script execution engine with Cedar policy authorization for every system operation.
Justy and Cody dig into Trusted Remote Execution (REX), a sandboxed Rhai script engine that runs Cedar policy authorization checks against every single system call — file I/O, network, processes — before anything actually executes. They cover why TOCTOU mitigations matter, how the Cedar + Rhai pairing works architecturally, who actually reaches for something like this, and what a weekend project with it might look like.
-
The Roadmap to Mastering Tool Calling in AI Agents
Justy and Cody talk through Machine Learning Mastery's roadmap for production-grade tool calling in AI agents, focusing on contracts, error handling, parallel calls, catalog size, security boundaries, and practical evaluation.
-
Four Agent Orchestration Patterns
Justy and Cody dig into a benchmark study testing four multi-agent orchestration patterns across 10,000 SEC filings — sequential pipeline, parallel fan-out, hierarchical supervisor-worker, and reflexive self-correcting loop — unpacking the real cost-accuracy-scale trade-offs and how to pick the right one for production.
-
The app store for robots has arrived: Hugging Face launches open source Reachy Mini App Store with 200+ apps
Hugging Face launches an app store for Reachy Mini, a $299 open-source desktop robot, hosting 200+ community-built applications. The store removes the roboticist barrier by letting non-technical users build robot apps in minutes using plain English descriptions and an AI agent called ML Intern. Cody questions whether this solves a real problem or is mostly marketing hype around a niche hardware play, while Justy argues the accessibility angle and the removal of weeks-long integration work represents genuine market shift.
-
Gemini API File Search is now multimodal: build efficient, verifiable RAG
Justy and Cody dig into Gemini API File Search getting multimodal retrieval, metadata filters, and page-level citations, and why that matters for anyone tired of flaky RAG over PDFs and image folders.
-
From Skill Text to Skill Structure: The Scheduling Structural Logical Representation for Agent Skills
Justy and Cody dig into the SSL (Scheduling-Structural-Logical) representation paper from Peking University — a structured, three-layer JSON schema designed to replace the messy, text-heavy SKILL.md files that LLM agent systems currently rely on. They cover why parsing natural language skill docs is a real bottleneck, how SSL's three layers (scheduling, structural, logical) map to classical AI theory, what the benchmark numbers actually mean, and whether this is something builders can use today.
-
Qwen AI Releases Qwen Scope an Open Source Sparse Autoencoders Sae Suite That Turns LLM Internal Features Into Practical Development Tools
Justy and Cody unpack Qwen-Scope, Qwen AI’s open-source sparse autoencoder suite for making LLM internals more usable in debugging, steering, and benchmark analysis.
-
Building with Gemini Embedding 2: Agentic multimodal RAG and beyond Google Developers Blog
Exploring Next, episode 357. Gemini Embedding 2 just made multimodal retrieval a lot more practical: text, images, video, audio, and PDFs can all land in one embedding space, which changes search, RAG, and agent workflows.
-
Why AI Engineers Are Moving Beyond LangChain to Native Agent Architectures | Towards Data Science
Justy and Cody unpack why teams are moving from LangChain-style frameworks toward native agent architectures once LLM apps hit production pressure.
-
Tuning Deep Agents to Work Well with Different Models
Justy and Cody dig into LangChain’s new Deep Agents model-specific harness profiles. Cody is skeptical that prompt-and-tool tuning is a durable win, while Justy sees a practical adoption path for builders who keep hitting model-specific quirks. They land on a cautious take: useful, real, and probably underappreciated, but not magic.
-
DBmaestro MCP Server Puts Natural Language in Control of Database Pipelines
Episode 351 of Exploring Next looks at DBmaestro’s new MCP server, which lets AI agents trigger governed database DevOps workflows through natural language while staying inside existing permissions and audit controls.
-
You don't need an expensive GPU to run a local LLM that actually works
Cody and Justy examine the claim that you don't need an expensive GPU to run capable local LLMs. Cody opens skeptical about quantization trade-offs and real-world inference speed; Justy pushes back with the actual user story—cost-conscious builders and privacy-first home automation. They dig into what 'works' really means, explore the CPU-only vs. GPU trade-off, and land on a nuanced take: smaller quantized models on mid-range hardware are genuinely usable now, but marketing around this can oversell the experience. Build Next includes testing Ollama on a specific budget GPU and benchmarking a 7B quantized model on a CPU-only rig.
-
Mistral AI Introduces Workflows for Orchestrating Enterprise AI Processes
Mistral AI launches Workflows, an enterprise orchestration layer built on Temporal that brings stateful execution, human-in-the-loop checkpoints, and fault tolerance to multi-step AI processes. Justy and Cody dig into what it actually solves, where the real hard problems still live, and what to try this weekend.
-
Warp's gamble: Going open source to take on closed Source rivals
Warp is open-sourcing its terminal client while keeping parts of its cloud and AI stack closed, which makes this a pretty direct bet on trust, adoption, and developer workflow at a moment when more people are living in terminals with AI bolted on.
-
Stop Hitting Claude Code Limits
Claude Code's usage limits aren't the real problem—how you set it up is. Four controllable causes drive 85% of overspend: cache misses, context bloat, wrong model routing, and token-heavy input formats. One user cut costs from $1,389/mo to $200/mo by locking tools at session start, disabling 1M context, delegating to cheaper subagents, and swapping screenshots for accessibility trees. Real fixes are copy-paste configuration changes and workflow tweaks, not waiting for Anthropic.
-
SketchVLM: Vision language models can annotate images to explain thoughts and guide users
In this episode, Justy and Cody dig into SketchVLM, a training-free framework that lets vision-language models explain answers by drawing editable SVG annotations on top of images. They talk through why text-only answers are hard to verify, how SketchVLM uses a draft-and-refine loop plus visual grounding to produce overlays, where it looks production-friendly, and where the trade-offs still show up.
-
This closes a loop I've been working on for three months. Every agent harness debate has a hidden assumption: that t...
Rohit Ghumare's thread argues the agent harness debate is asking the wrong question. Instead of debating how thick the wrapper around a backend should be, the insight is that agents, queues, sandboxes, and services should all participate in the same execution model — built on three primitives: Worker, Function, and Trigger. The payoff is live discovery, live extensibility, and a single trace across everything.
-
Sentry’s Seer Agent lets developers debug production issues in natural language
Exploring Next, episode 335. Sentry’s Seer Agent brings natural-language debugging into production incidents, aiming to cut the time teams spend digging through traces, logs, and issue context.
-
Contexts are Never Long Enough: Structured Reasoning for Scalable Question Answering over Long Document Sets
SLIDERS solves the aggregation bottleneck in document question answering by extracting information into a relational database and reasoning over structured data via SQL instead of concatenating chunks. It uses data reconciliation to fix duplicates and inconsistencies, outperforming GPT-4 on long-context benchmarks and scaling to 36M tokens.
-
Text Summarization with Scikit LLM MachineLearningMastery
Justy and Cody kick around a MachineLearningMastery post on using scikit-LLM for text summarization inside scikit-learn pipelines. Cody is skeptical about the real value of wrapping a summarizer as a transformer, while Justy argues it fits messy, text-heavy workflows where teams already live in sklearn. They land on a cautious verdict: useful for specific preprocessing jobs, but not a magic shortcut, especially once cost, latency, and summary quality enter the picture.
-
An open source spec for Codex orchestration: Symphony.
Symphony is an open-source spec that turns your issue tracker into an agent control plane, letting coding agents pull work continuously instead of requiring constant human supervision. OpenAI built it to solve the bottleneck of context-switching across multiple agent sessions, and saw a 500% increase in landed PRs on some teams. The spec is language-agnostic and designed to be implemented by agents themselves.
-
Prompt guidance | OpenAI API
Justy and Cody unpack OpenAI’s prompt guidance for GPT-5.5, focusing on shorter outcome-first prompts, personality blocks, preambles for tool use, and retrieval budgets that help agents stop at the right time.
-
Opentabs Dev/opentabs
OpenTabs lets AI agents call real web APIs through your browser session—Discord, Slack, GitHub, Notion, and 100+ more—without screenshots, DOM scraping, or API keys. Cody questions the security model and plugin discovery overhead; Justy argues the authenticated-session angle solves a real friction point for AI workflows. They land on it as genuinely useful for power users and developers, but adoption hinges on plugin ecosystem maturity and trust.
-
Git
Justy and Cody look at ai-cli-mcp, a package that turns several coding agents into background jobs from one MCP server. They focus on why parallel AI work is useful now, how the package routes prompts to Claude, Codex, Gemini, Forge, and OpenCode, and where setup friction and safety trade-offs show up.
-
GitHub Kwstx/engram Translator: layer that lets you connect any agent, any tool, any api together.
In this episode, Justy and Cody dig into Engram, an interoperability layer for AI agents, tools, and APIs that tries to reduce the adapter churn people keep running into as standards multiply. They talk through protocol translation, semantic schema repair, weighted routing, and the practical friction of adoption, then close with a few concrete build ideas.
-
panini/README.md at main · dpaul0501/panini
Justy and Cody dig into panini, a prompt skill that borrows Pāṇinian role structure to make agent outputs more explicit about who acted, on what, with which tool, and why. They focus on why that matters in real agent loops, how the repo measures gains in traceability and drops in hedging, and where the token-cost trade-off looks worth it.
-
GitHub Dejuknow/md redline: Inline review comments for markdown specs. Built in MCP server hands feedback directly to your AI agent.
On Exploring Next episode 315, Justy and Cody look at md-redline, a local review layer for markdown specs, prompts, and design docs. They dig into why inline feedback matters in agentic workflows, how invisible HTML markers keep comments inside the source file, and why an MCP server that can pause an agent mid-task changes the review loop. They also weigh the adoption friction, the file-based trade-offs, and a few practical ways to try it.
-
AgentSPEX: An Agent SPecification and EXecution Language
Justy and Cody dig into AgentSPEX, a YAML-based language and runtime for building LLM agents with explicit control flow, typed steps, reusable submodules, parallel execution, and state management. They focus on the gap between loose ReAct prompting and Python-heavy orchestration tools, then unpack how AgentSPEX separates workflow specification from execution while still supporting tools, sandboxing, checkpointing, replay, and visual editing. The conversation lands on who this is for, where it feels shippable, and what a solo builder could try this weekend.
-
One Developer, Two Dozen Agents, Zero Alignment
Ace is a GitHub Next prototype that treats coding with agents as a shared workspace instead of a solo tool. The skepticism is whether teams really want another surface for coordination, even if the architecture is clever.
-
Harness engineering for coding agent users
Justy and Cody dig into harness engineering for coding agents: the practical idea that trust in AI-written code comes less from the model itself and more from the guardrails, checks, and feedback loops wrapped around it. They unpack feedforward guides versus feedback sensors, deterministic tooling versus LLM-based judgment, and why teams should treat the human as the person tuning the harness instead of reviewing every tiny diff forever.
-
Harness engineering: leveraging Codex in an agent First world
Justy and Cody dig into OpenAI’s writeup on building a product with Codex doing all the coding, and why the real shift is from typing code to designing an environment agents can reliably operate in. They cover the no-manual-code constraint, the repo-as-system-of-record approach, agent-readable docs, isolated worktrees, UI and observability access, and why this matters for teams trying to ship faster without drowning in review and QA.
-
Anthropic just launched Claude Design, an AI tool that turns prompts into prototypes and challenges Figma
Anthropic’s Claude Design is a big deal because it aims to collapse the gap between idea, prototype, and stakeholder feedback. Justy and Cody dig into why that matters now, what Claude Design likely does under the hood, why pairing it with Opus 4.7 matters, and where it could genuinely pressure Figma versus where the old product realities still bite.
-
Pi Monorepo
Exploring the Pi Monorepo and its tools for building AI agents and managing LLM deployments.
-
1) Pick a user bin dir and move/rename the binary
Exploring the SigMap tool and its impact on AI coding context
-
Build
Exploring Kumo, a lightweight AWS service emulator written in Go, and its applications in CI/CD testing and local development.
-
Context Engine MCP | Augment Code
Exploring the Context Engine MCP and its potential to revolutionize coding agents
-
How to Implement Tool Calling with Gemma 4 and Python MachineLearningMastery
Episode 287 of Exploring Next dives into the world of tool calling with Gemma 4 and Python, exploring how to build a local, privacy-first tool-calling agent.
-
Stop Treating AI Memory Like a Search Problem | Towards Data Science
Episode 285 of Exploring Next explores the limitations of treating AI memory like a search problem and delves into the concept of a lifecycle memory system that actively manages superseded information.
-
Minimax Releases Mmx CLI a Command Line Interface That Gives AI Agents Native Access to Image Video Speech Music Vision and Search
Exploring the MMX-CLI, a command-line interface that gives AI agents native access to image, video, speech, music, vision, and search capabilities.
-
Replit taps RevenueCat to help vibe Coders make money
Replit and RevenueCat team up to help developers monetize their apps, making it easier for vibe-coders to make money
-
Deep Agents Deploy: an open alternative to Claude Managed Agents
Exploring Next Episode 282: Deep Agents Deploy, an open alternative to Claude Managed Agents
-
LLM Wiki
Exploring the LLM Wiki concept and its potential applications
-
Andrej Karpathy Just 10x’d Everyone’s Claude Code
Episode 271 of Exploring Next dives into Andrej Karpathy's recent work on Claude, which has significantly improved its capabilities. The discussion revolves around the substance of the project, its architecture, and how it works, with a focus on the product angle and technical aspects.
-
Open Source orchestration for zero Human companies
Episode 269 of Exploring Next dives into the world of open-source orchestration for zero-human companies, focusing on Paperclip, a Node.js server and React UI that coordinates AI agents to run a business.
-
Running local models on Macs gets faster with Ollama's MLX support
Ollama just added MLX support for Apple Silicon Macs, promising significantly faster local LLM performance through better unified memory usage. We break down what this actually means, why it matters as local models gain momentum, and the technical architecture that makes it work.
-
Reddit The heart of the internet
Izzo and Boone dissect the leaked Claude Code prompts and explore how to build better AI agents by studying Anthropic's approach to prompt engineering, focusing on practical patterns like negative rules, risk tiers, and verification agents.
-
Prismo Optimize AI Costs
Prismo is an AI cost optimization platform that acts as a drop-in proxy between your application and AI providers like OpenAI and Anthropic. By routing requests through Prismo's gateway, teams get real-time spend tracking, automated budget enforcement, and intelligent model routing that can reduce costs by up to 40%. The platform requires just a one-line code change to integrate and provides full visibility into AI spending across teams, services, and models.
-
Temm1e/tems lab/perpetuum/RESEARCH PAPER.md at main · temm1e Labs/temm1e
Perpetuum is a framework that transforms LLM agents from request-response systems into perpetual, time-aware entities capable of scheduling, monitoring, and autonomous action. Built into the production TEMM1E runtime, it introduces temporal cognition, LLM-cognitive scheduling, and concern-based multitasking through an enabling framework principle that delegates intelligence to the LLM while providing infrastructure it can't handle itself.
-
Designing delightful frontends with GPT 5.4 | OpenAI Developers
OpenAI's GPT-5.4 brings significant improvements to frontend development with enhanced image understanding, native tool integration, and computer use capabilities. The model can now generate production-ready interfaces with sophisticated visual design, incorporating mood boards, visual references, and automated testing through Playwright. Key improvements include better UI reasoning, complete app functionality, and self-verification workflows that enable more autonomous development cycles.
-
Claude Code Python Porting Workspace
A deep dive into claude-code, a Python porting workspace that reimplements Claude's exposed codebase architecture. We explore the technical approach, ethical considerations around AI source reimplementation, and what this means for the future of reverse-engineering AI systems.
-
Reddit The heart of the internet
A developer built Phantom, an open-source persistent AI agent that runs 24/7 on its own VM with vector memory, self-evolution capabilities, and MCP server integration. The agent autonomously installed ClickHouse, built analytics dashboards, created Discord integrations, and even monitors its own infrastructure — all without explicit instructions.
-
Using OpenClaw as a Force Multiplier: What One Person Can Ship with Autonomous Agents | Towards Data Science
Nick Lawson shares his production system running 8 orchestrator agents and 35 personas on OpenClaw to manage content creation, infrastructure, and home automation. We dig into the architecture: heavyweight orchestrators making decisions on Opus, lightweight personas executing tasks on cheaper models, and the cost optimization strategies that make autonomous agents economically viable for solo builders.
-
Natural Language Agent Harnesses
Exploring Natural-Language Agent Harnesses (NLAHs) — a new approach to making AI agent control logic portable and editable in plain English, plus the runtime system that executes these natural language harnesses across different environments.
-
Meet Gitagent the Docker for AI Agents That Is Finally Solving the Fragmentation Between Langchain Autogen and Claude Code
GitAgent is a containerization platform for AI agents that standardizes deployment across LangChain, AutoGen, and Claude frameworks. It provides Docker-like packaging, unified APIs, and environment isolation to solve the current fragmentation in agent development.
-
Preparing IT for AI Agents: How MCP Shapes the Future of AI
Izzo and Boone explore MCP (Model Context Protocol) and how it's positioning IT infrastructure for AI agents, diving into the protocol's architecture, orchestration patterns, and what it means for organizations preparing their systems for autonomous AI workflows.
-
7 Steps to Mastering Memory in Agentic AI Systems MachineLearningMastery
Izzo and Boone dive deep into the seven-step framework for implementing memory in agentic AI systems, exploring why memory is a systems design problem rather than just throwing more context at models. They break down the four types of agent memory, explain the crucial differences between RAG and memory, and get into the architectural decisions around storage, retrieval, and forgetting that make production agents actually useful over time.
-
AI Coding Assistants Haven’t Sped up Delivery Because Coding Was Never the Bottleneck
Agoda's analysis of AI coding assistants reveals they boost individual developer output but don't speed up project delivery because coding was never the real bottleneck. The constraint has shifted upstream to specification and verification, fundamentally changing how engineering teams should be structured and what work humans focus on.
-
Cloudflare’s new Dynamic Workers ditch containers to run AI agent code 100x faster
Cloudflare launches Dynamic Workers, ditching containers for millisecond-starting isolates that run AI agent code 100x faster. The tech enables 'Code Mode' — where LLMs write TypeScript functions instead of chaining tool calls, cutting token usage by 81%. Built on V8 isolates, it's positioning sandboxing as a strategic layer in the AI stack.
-
Developer’s Guide to AI Agent Protocols Google Developers Blog
Izzo and Boone explore Google's new Agent Development Kit and the emerging protocols solving AI agent integration hell - MCP for data connections, A2A for agent-to-agent communication, and UCP for commerce workflows. They build a restaurant supply chain agent live, showing how these protocols eliminate custom integration code.
-
GitHub pcvelz/superpowers: An agentic skills framework & software development methodology that works CC task management support
Izzo and Boone explore Superpowers Extended, a fork of the open-source Superpowers framework specifically designed for Claude Code users. They dig into how it transforms AI-assisted development from chaotic back-and-forth into structured workflows with native task management, dependency tracking, and enforced methodologies like test-driven development.
-
Langsmart Publishes Industry’s First p95 Semantic Cache Benchmarks for On Premises AI Gateway, Challenges Market: “Show Me the p95”
Langsmart's Smartflow platform achieved 10.2x faster AI response times in Fortune 200 testing, delivering sub-300ms p95 latency on modest on-premises hardware while challenging the industry to publish real performance benchmarks.
-
Reddit The heart of the internet
Lundrog built an open-source framework called agent-guardrails-template to control AI coding agents and prevent them from breaking codebases. The system uses four safety laws, active enforcement via a Go MCP server, and risk-based decision matrices to reduce AI-caused incidents by 78%.
-
NanoClaw and Docker partner to make sandboxes the safest way for enterprises to deploy AI agents
NanoClaw teams up with Docker to solve enterprise AI agent security through proper sandboxing. We break down why agents break traditional containers, how Docker Sandboxes work differently, and what this means for multi-agent deployment at scale.
-
The team behind continuous batching says your idle GPUs should be running inference, not sitting dark
The team behind continuous batching says your idle GPUs should be running inference, not sitting dark Sean Michael Kerner March 12, 2026 Credit: Image generated by VentureBeat with Nano-Banana-2 Every GPU cluster has dead time. Training jobs finish, workloads shift and hardware sits dark while power and cooling costs keep running.
-
Enterprise agentic AI requires a process layer most companies haven’t built
Enterprise agentic AI adoption faces a critical infrastructure gap: 85% of companies want AI agents within three years, but 76% lack the process optimization foundation to support them. The real blocker isn't technology—it's siloed teams, disconnected systems, and AI agents operating without business context.
-
Use agent identity with Secret Manager
Exploring Next dives deep into a cutting-edge tech development that's reshaping how we think about distributed systems and real-time processing. Izzo and Boone break down the architecture, examine the trade-offs, and connect it to current market needs.
-
Understanding Context and Contextual Retrieval in RAG | Towards Data Science
Episode 215 dives deep into contextual retrieval in RAG systems, exploring how traditional RAG loses crucial context when documents are chunked and how Anthropic's contextual retrieval approach dramatically improves accuracy by generating helper text that situates each chunk within its original document. Izzo and Boone examine the core technical mechanisms, implementation details, and real-world impact of this technique.
-
Is RAG Still Needed? Choosing the Best Approach for LLMs
Izzo and Boone dive deep into the current state of RAG versus fine-tuning for LLMs, examining when retrieval-augmented generation still makes sense and when newer approaches might be better. They break down the technical trade-offs, cost implications, and real-world performance considerations that developers face when choosing between RAG, fine-tuning, and hybrid approaches.
-
Building frontend UIs with Codex and Figma
OpenAI's new Figma MCP server creates a bidirectional bridge between Figma designs and Codex code generation, allowing developers to extract design context from Figma files for code generation and push live UI back to Figma canvas for iteration. The integration supports full roundtrip workflows from design to code and back.
-
Copilot Content Exclusion REST API in public preview GitHub Changelog
GitHub's new Content Exclusion REST API lets organizations programmatically manage what code Copilot can and can't learn from — a game-changer for enterprises juggling AI productivity with IP protection.
-
Visual imitation learning: Guidde trains AI agents on human 'expert video' instead of documentation
Guidde raised $50M to solve enterprise AI's 'last mile' problem by training agents on video recordings of human experts, not documentation. Instead of PDFs, they capture rich telemetry—every click, scroll, and DOM change—creating 'digital world models' that let AI navigate complex enterprise software with human-like spatial awareness.
-
How to Use Memory in Agent Builder
LangChain's Agent Builder uses filesystem-based memory to get smarter over time, storing both short-term task context and long-term instructions as Markdown files. The system includes specialized 'skills' that load contextually and supports direct memory editing for fine-tuned control.
-
openclaw with ollama (Zero cost AI Assistant)
Izzo and Boone explore OpenClaw, an open-source AI assistant framework that runs entirely locally with Ollama. They dig into how it creates zero-cost AI workflows, the agent architecture with workspace management and subagent spawning, and why running your own AI stack locally matters for both privacy and cost control.
-
OpenAI Publishes Codex App Server Architecture for Unifying AI Agent Surfaces
InfoQ Homepage News OpenAI Publishes Codex App Server Architecture for Unifying AI Agent Surfaces Architecture & Design Orchestrating Production-Ready AI Workflows with Apache Airflow (Webinar Mar 5th) OpenAI Publishes Codex App Server Architecture for Unifying AI Agent Surfaces Feb 17, 2026 3 min read by Eran Stiller Write for InfoQ Feed your curiosity. Help 550k+ global senior developers each month stay ahead.
-
GitHub BankrBot/openclaw skills: Moltbot skill library for AI agents. Including polymarket, crypto trading, DeFi operations, automation, and more. Open a PR to add skills.
OpenClaw Skills Library Pre-built capabilities for ai agents to interact with crypto infrastructure. Skills enable autonomous DeFi operations, token launches, onchain messaging, and protocol integrations through natural language interfaces.
-
Google Chrome ships WebMCP in early preview, turning every website into a structured tool for AI agents
Google Chrome launches WebMCP in early preview - a new browser API that lets websites expose structured tools directly to AI agents, eliminating the need for expensive screenshot-based scraping and fragile DOM parsing.
-
recipes/GLM/GLM5.md at main · vllm Project/recipes
Episode 183 explores GLM5, a new language model architecture that's pushing boundaries in multimodal understanding and reasoning. Izzo and Boone dive deep into how it handles mixed text-image inputs, its novel attention mechanisms, and why vLLM is building dedicated recipes for deployment at scale.
-
OpenAI upgrades its Responses API to support agent skills and a complete terminal shell
OpenAI's major Responses API upgrade introduces Server-side Compaction for persistent agent memory, hosted shell containers with full terminal environments, and support for the universal Skills standard - transforming AI agents from forgetful assistants into reliable, long-running digital workers.
-
Kong launches Context Mesh to turn enterprise APIs into agent Ready tools Help Net Security
Industry News February 11, 2026 Share Kong launches Context Mesh to turn enterprise APIs into agent-ready tools Kong has announced Kong Context Mesh, a product that automatically discovers enterprise APIs, transforms them into agent-consumable tools, and deploys them with runtime governance. “Organisations have spent years building APIs as the nervous system of the enterprise.
-
Transformers.js v4 Preview: Now Available on NPM!
Transformers.js v4 brings massive performance improvements with a new C++ WebGPU runtime, modular architecture, and standalone tokenizer library. Now runs state-of-the-art AI models directly in browsers, Node, and Deno with hardware acceleration.
-
Alibaba Open Sources Zvec an Embedded Vector Database Bringing Sqlite Like Simplicity and High Performance on Device RAG to Edge Applications
Alibaba open-sources ZVec, an embedded vector database that brings SQLite-like simplicity to on-device RAG applications, enabling high-performance semantic search without cloud dependencies.
-
Next Moca Releases Agent Definition Language as an Open Source Specification
Next Moca has open-sourced Agent Definition Language (ADL), a specification that standardizes how AI agents are defined across platforms. Think OpenAPI for agents - it provides a declarative format for defining agent identity, tools, permissions, and governance metadata to solve the growing fragmentation problem in production AI systems.
-
GitHub Win4r/team tasks: Multi agent pipeline coordination: Linear, DAG, and Debate modes for AI agent orchestration
A Python CLI tool that coordinates multi-agent development workflows through three distinct modes: linear pipelines for sequential work, DAG-based dependency graphs for parallel execution, and debate mode for multi-agent deliberation. Built specifically for OpenClaw integration with no external dependencies.
-
How PMs use the Codex app
Product managers are using a new app called Codex to bridge the gap between product vision and engineering execution. We explore how it works, why it's gaining traction among PMs, and what makes it different from traditional project management tools.
-
Introducing: React Best Practices Vercel
Vercel releases react-best-practices, a structured framework that captures 10+ years of React optimization knowledge. It focuses on ordering performance work by impact—starting with eliminating waterfalls and reducing bundle size before micro-optimizations. The repository includes 40+ rules across 8 categories and compiles into a single document that AI coding agents can use for code reviews and refactoring suggestions.
-
Docker versus Nix: The quest for true reproducibility
In this episode, we dive into the differences between Docker and Nix, exploring how they each approach reproducibility in software environments. As tech continues to evolve, ensuring consistency across development, testing, and production is paramount. We’ll examine how these tools can impact developers, organizations, and ultimately, the end users.
-
Context Engineering: An Introduction to the Information Environment for LLMs
A deep dive into context engineering reveals how structuring information for large language models enhances their performance and relevance. It’s more than just managing prompts—it's about creating a dynamic environment that allows AI to engage intelligently. This discussion explores why these strategies matter, who stands to benefit, and practical examples of their application.
-
Reddit The heart of the internet
In today's episode, we dive deep into an exciting achievement in the world of game development using AI. One developer crafted a pixel-art open-world shooter in just 24 hours using Gemini 3.0 Pro for both coding and art. We explore what this means for developers, the implications of using AI in creative workflows, and the future of game design. Join us as we unpack the significance of this innovative approach and its potential impact on the gaming industry.
-
Agent Device
In this episode, we explore the innovative CLI tool 'agent-device' that allows developers to automate interactions with iOS and Android devices. We'll dive into how it enhances mobile testing and development workflows, the real-world implications of its features, and practical use cases that demonstrate its utility.
-
10 strategies to reduce MCP token bloat
In today's tech landscape, managing token bloat is critical for efficient application performance. This dialogue dives into strategies for reducing MCP token bloat, emphasizing its importance for developers and organizations alike. The hosts explore practical solutions and real-world implications, showcasing how these strategies can lead to smoother operations and enhanced user experiences.
-
Qwen3 Coder Next: How to Run Locally | Unsloth Documentation
In this episode, we explore Qwen3-Coder-Next, a groundbreaking coding model that enables local execution with high efficiency. We discuss its capabilities, real-world applications, and why it’s a game-changer for developers and tech enthusiasts.
-
How to Build Your Own Custom LLM Memory Layer from Scratch | Towards Data Science
In this episode, we explore innovative ways to enhance large language models (LLMs) with custom memory layers that improve user interactions. By enabling LLMs to remember past user interactions, we can drive personalization and efficiency in AI applications. Join us as we unpack how to build these memory systems from scratch and what this means for the future of conversational agents.
-
Context Engineering: Prompt Management, Defense, and Control
The dialogue explores the nuances of context engineering in LLMOps, focusing on prompt management and versioning. It discusses why this is crucial for reliability in AI applications and how structured techniques can improve outputs while preventing errors. The conversation also highlights the real-world implications of these advancements for developers, businesses, and end-users, alongside practical takeaways for implementation.
Dev ToolsBlog -
OpenAI launches new macOS app for agentic coding | TechCrunch
OpenAI's new macOS app for agentic coding is reshaping the landscape of software development by enabling AI agents to autonomously handle complex coding tasks, significantly speeding up the development process. This episode explores how this technology works, its implications for developers, and real-world applications.
-
Agent Trace
Agent Trace is an innovative specification aimed at tracking AI-generated code contributions in version-controlled environments. It establishes a framework for clear attribution between human and AI authors, which is increasingly important as AI tools become central in software development. By implementing this standard, teams can ensure transparency, facilitate collaboration, and maintain accountability within their codebases, ultimately leading to better development practices.
-
Introducing Moltworker: a self hosted personal AI agent, minus the minis
In this episode, we explore Moltworker, a self-hosted personal AI agent that operates seamlessly on Cloudflare's infrastructure. We discuss its implications for privacy, the power of self-hosting, and how it simplifies AI integration for everyday users.
-
Terminal 1
In today's discussion, we dive deep into Open Claude Cowork, a revolutionary tool that integrates AI with workplace communication, enabling seamless automation across multiple apps. This technology could redefine productivity, making it accessible to developers and businesses alike.
-
Reddit The heart of the internet
Reddit has become a vital platform for discussions around emerging technologies, especially AI and autonomous systems. The recent AMA with the Qoder team reveals how developers are leveraging AI to enhance coding productivity. This episode dives into the implications of autonomous coding, the benefits it offers, and how it can transform software development practices.
-
'Ralph Wiggum' loop prompts Claude to vibe clone software • The Register
This episode dives into the revolutionary coding technique called 'Ralph,' which leverages agentic AI to clone software inexpensively. The implications for the software industry are profound, as it threatens traditional development roles and practices. Join us as we discuss why this matters, who benefits, and what it means for the future of tech.
-
Anthropic extends MCP with a UI framework
Anthropic's latest extension of its MCP (Managed Conversation Platform) introduces a UI framework, allowing developers to create customized applications that leverage AI capabilities. This development could democratize access to advanced AI tools and improve application design.
-
RAG isn’t dead, but context engineering is the new hotness
The emergence of context engineering signifies a pivotal shift in how we handle retrieval-augmented generation (RAG) technologies, impacting everything from AI applications to data management across various industries. This episode explores the practical implications of context engineering, who stands to benefit, and how it compares to existing solutions.
-
LLM Generated Newspaper Provides Ultimate In Niche Publications
This episode dives into the innovative use of LLMs to create niche newspaper publications, exploring how AI can tailor content to specific audiences while considering the implications for journalism and information consumption.
-
Context Engineering: Foundations, Categories, and Techniques of Prompt Engineering
In this episode, we unravel the significance of context and prompt engineering in large language models (LLMs). These techniques are critical for creating efficient and reliable AI applications. We discuss the fundamental principles of prompt engineering, its implications in real-world systems, and explore how crafting the right prompts can drastically influence model performance. Join us as we dissect how these innovations empower businesses and enhance user experiences.
Dev ToolsBlog -
Choosing an LLM in 2026: The Practical Comparison Table (Specs, Cost, Latency, Compatibility)
In this episode, we dive into the nuances of selecting the right large language model (LLM) in 2026. With insights on context, cost, latency, and compatibility, we discuss how these factors shape effective prompt engineering and the importance of making informed model choices. Our conversation also explores real-world implications and provides practical examples for businesses looking to leverage LLMs.
-
Giving Agents a Visual Voice: MCP Apps Support in VS Code
This podcast episode explores the new MCP Apps feature in VS Code, which empowers AI coding agents with interactive visual capabilities. This innovation transforms the way developers collaborate with AI tools, enhancing productivity and problem-solving. Through real-world applications and examples, hosts discuss the implications and potential use cases of this exciting feature.
-
Conversational AI doesn’t understand users — 'Intent First' architecture does
This episode explores the revolutionary 'Intent First' architecture in conversational AI, which improves user experiences by accurately understanding intent before delivering responses. We discuss why this matters in various industries and highlight real-world implications for companies and consumers alike.
-
GitHub AvdLee/SwiftUI Agent Skill: Add expert SwiftUI Best Practices guidance to your AI coding tool (Agent Skills open format).
The SwiftUI Agent Skill is revolutionizing the way developers approach coding in SwiftUI by offering expert guidance through AI tools, enhancing productivity and code quality. This episode explores its implications, practical applications, and why it matters for modern development.
-
ErZaUgMTdP
This episode delves into a groundbreaking tool named Drift, designed to enhance codebase intelligence by leveraging Abstract Syntax Tree (AST) parsing. We explore how it addresses the common bottleneck of context limitations that hinder AI's effectiveness in software development. Through Drift, developers can now streamline their workflows, minimize audit loops, and improve code reliability and security. We discuss its implications for the industry and how this innovation could change programming practices.
-
Agent Sandbox
The Agent Sandbox offers a secure environment for executing AI coding agents, addressing critical security concerns while allowing developers to utilize powerful tools like Claude Code. This episode dives into the implications of this technology, who it benefits, and how it can transform development workflows.
-
Learn RAG & MCP Fundamentals
This podcast episode delves into the importance of mastering Retrieval Augmented Generation (RAG) and Model Context Protocol (MCP) to enhance AI's capabilities in real-world applications. Hosts discuss how these technologies empower developers to create integrated systems that leverage private data effectively and enable AI to interact with various software seamlessly.
-
Anthropic working on MCP Apps with interactive UI components
Anthropic is enhancing its Claude Cowork platform with new interactive UI components that can revolutionize how users engage with AI applications. This development could streamline workflows, improve collaboration, and empower developers to create richer interactions, drawing clearer parallels with existing technology.
-
LangChain vs LangGraph: Why One's a Drive Through and the Other's a Buffet
In this episode, we explore the differences between LangChain and LangGraph, illustrated through food analogies. We discuss their functionalities, real-world applications, and the importance of choosing the right tool for the task at hand. The episode emphasizes decision-making in AI and how it impacts efficiency and user experience.
-
Beyond Hybrid RAG That Actually Works Vector Bm25 Graphrag Reranking in Python Full Code 731a8f827a80
This episode dives into the breakthrough of Tri-Modal Hybrid RAG, which combines BM25, Vector, and GraphRAG techniques. We explore how this innovative approach enhances search accuracy, addresses common pitfalls in retrieval, and ultimately improves user experience across various applications. The conversation highlights the significance of effective information retrieval in tech and real-world scenarios.
-
Build Your First Claude Code Skill a Simple Project Memory System That Saves Hours 1d13f21aff9e
The new project-memory skill for Claude Code tackles the problem of AI amnesia, allowing coding assistants to retain context and history across sessions, thus significantly improving developer productivity. This episode explores how such skills can save time and enhance coding efficiency.
-
AI Periodic Table Explained: Mapping LLMs, RAG & AI Agent Frameworks
In this episode, we dive into the transformative power of YouTube as a platform that allows users to create, share, and consume a diverse range of content. We explore its significance in democratizing content creation and its broader societal implications.
-
MCP powered RAG Over Complex Docs
In this episode, we explore the integration of MCP-powered Retrieval-Augmented Generation (RAG) over complex documents, emphasizing its real-world applications and significance. Hosts discuss how this technology transforms document processing and retrieval, providing a fresh perspective on managing complex data efficiently.
-
Webgpu Changed How I Think About Web Performance D63e771d1cee
WebGPU is revolutionizing web performance by drastically enhancing graphics and data processing speeds, showing a 23x improvement over WebAssembly in practical applications. This shift in technology not only benefits developers looking for efficient solutions but also enhances user experiences in data-intensive applications.
-
Awesome Claude Skills/brand guidelines/SKILL.md at master · ComposioHQ/awesome Claude Skills
In this episode, we explore the emergence of Claude, a powerful AI tool that enhances collaboration and productivity by integrating various skills. We discuss the significance of its brand guidelines, how it affects user engagement, and what it means for the future of digital collaboration. Real-world implications are examined through hypothetical scenarios and comparisons with existing tools.
-
LangGraph Explained from Scratch | Aman Kharwal
This episode dives into LangGraph, a new library that transforms how we build intelligent agents using Large Language Models. We'll explore its unique graph-based approach, practical applications, and why this matters for developers and users alike.
-
Memory: How Agents Learn
In this episode, we dive into the critical aspect of memory in AI agents, exploring how it enables learning and the transformative implications for user experience and system efficiency. We discuss the types of memory—session, user, and learned—and how they contribute to smarter, more effective agents. Join us as we uncover the potential of these technologies and their real-world applications.
-
Agent Skills vs MCP
The discussion centers on the relationship between Skills and MCP (Multi-Channel Protocol) in AI development, emphasizing how they complement rather than replace each other. Host A and Host B explore the implications of this synergy, the role of institution knowledge, and how this understanding can improve AI functionality in real-world applications.
-
React2Shell is the Log4j moment for front end development
The emergence of the React2Shell vulnerability marks a pivotal moment in front-end development, highlighting significant security concerns that could have far-reaching implications for developers and organizations alike. This dialogue delves into the substance of the vulnerability, its real-world impacts, and the necessary measures that must be taken to mitigate risks.
-
I reclaimed tons of disk space using this simple Docker maintenance app
In this episode, we dive into how a simple Docker maintenance app called Portainer can dramatically reclaim disk space for users, especially those running multiple containers on home servers or NAS devices. We discuss its functionalities, real-world benefits, and how it can streamline Docker management for enthusiasts and professionals alike.
-
GitHub KalyanKS NLP/RAG Interview Questions and Answers Hub: 100+ RAG interview questions with answers.
This episode dives into the importance of Retrieval-Augmented Generation (RAG) in enhancing the capabilities of language models, especially in reducing hallucinations and improving relevance in responses. We explore the challenges and strategies involved in implementing RAG, providing concrete use cases and implications for the tech community.
-
LLMs work better together in smart contract audits Help Net Security
This episode delves into how collaborative large language models (LLMs) enhance smart contract auditing, improving accuracy in detecting vulnerabilities. It highlights the innovative LLMBugScanner framework from Georgia Tech, which combines ensemble voting with fine-tuned models. We’ll explore why this matters in the blockchain ecosystem, who stands to benefit, and real-world implications that can prevent costly errors in smart contracts.
-
The Debugging Decay Index: Rethinking Debugging Strategies for Code LLMs
This podcast episode delves into the Debugging Decay Index (DDI), a new mathematical framework that highlights the rapid decline of AI debugging effectiveness and provides insights on optimizing debugging through timely interventions.
-
Introducing Agent Development Kit for TypeScript: Build AI Agents with the Power of a Code First Approach Google Developers Blog
The Agent Development Kit (ADK) for TypeScript allows developers to create powerful AI agents using a code-first approach, enhancing flexibility and control in AI development. This creates a seamless integration for JavaScript/TypeScript developers, enabling them to leverage existing skills and tools for more complex, autonomous systems.
-
Reddit The heart of the internet
This episode dives into the concept of 'Debugging Decay' in AI systems, particularly how ChatGPT's performance can degrade after multiple attempts at fixing coding errors. We'll discuss the implications of context pollution and how users can adapt their workflows for better results.
-
Meta
Meta's React Compiler 1.0 introduces automatic memoization to optimize React applications, enhancing performance without requiring code changes. This innovation promises significant improvements in load times and interaction speeds, benefiting developers and users alike.
-
The Complete Guide to Using Pydantic for Validating LLM Outputs
This episode dives into how Pydantic can validate outputs from large language models, ensuring reliable data. We'll explore the implications of these validations in real-world applications, the benefits for developers, and practical examples of how this can solve common issues when working with LLMs.
-
OpenAI, Anthropic, Google Agree to Develop Agent Standards Together
In an unprecedented collaboration, major players like OpenAI, Anthropic, and Google are agreeing to set technical standards for AI agents that could revolutionize how we automate white-collar work. This dialogue explores the significance of these standards and their potential real-world applications.
-
Don't Build Agents, Build Skills Instead – Barry Zhang & Mahesh Murag, Anthropic
In this episode, we dive into the transformative impact of YouTube on content creation and community building, exploring how it empowers users to become creators and redefine entertainment.
-
Claude Code is coming to Slack, and that's a bigger deal than it sounds | TechCrunch
The integration of Claude Code into Slack marks a significant shift in developer workflows, turning collaboration tools into powerful coding environments. This not only enhances efficiency but also raises vital questions about security and dependency management in software development.
-
Google launches managed MCP servers that let AI agents simply plug into its tools | TechCrunch
Google's launch of managed MCP servers aims to simplify how AI agents interact with various tools and data, reducing the complexity developers face while integrating these systems. This innovation could lead to more effective AI solutions for businesses and other sectors, as it streamlines connections to Google's robust services.
-
GraphRAG in Practice: How to Build Cost Efficient, High Recall Retrieval Systems | Towards Data Science
In this episode, we explore GraphRAG, a new methodology for building retrieval systems that blend graph and vector searches to enhance information retrieval efficiency. We discuss its practical implications, explore who benefits from this innovation, and examine concrete examples of usage scenarios.
-
Claude Code and Slack | Claude
Claude's new integration with Slack revolutionizes how coding tasks are handled in teams, allowing for seamless transitions from discussion to implementation, which streamlines workflows and enhances productivity.
-
Reddit The heart of the internet
In today's episode, we're diving into a fascinating solution designed to combat the issue of AI 'hallucinations'—the inaccuracies that AI models sometimes generate. We'll explore how a middleware solution can enhance trust in AI systems, specifically within the context of developing applications that rely on large language models.
-
Why the MCP Server Is Now a Critical Microservice
In this episode, we explore how the MCP server has become an essential microservice in modern software architecture. We discuss its implications for system scalability, reliability, and collaboration, and provide concrete examples to illustrate its real-world applications. Join us for insights into why adopting this technology could be transformative for businesses today.
-
Inside OpenAI: 2026 is the year of agents, AI’s biggest bottleneck, and why compute isn’t the issue
In this episode, hosts dive deep into the transformative impact of YouTube on content creation and digital communication. They explore how the platform empowers creators, fosters communities, and shifts traditional media paradigms, ultimately reshaping how we consume entertainment and information.
-
1brR9yRe6z
This episode explores groundbreaking advancements in creating dynamic NPC personalities that mimic real human behavior in games, integrating psychology, narrative, and social models. We discuss how these developments can revolutionize gaming experiences, enhance player immersion, and offer developers new tools for storytelling.
-
GitHub Dyoshikawa/rulesync
In this episode, we unpack Rulesync, a powerful Node.js CLI tool that streamlines AI development by generating uniform configuration files for various AI coding tools. We explore its implications for developers, the flexibility it offers in tool selection, and how it can enhance productivity across teams.
-
New Infrastructure as Code Tool "formae" Takes Aim at Terraform
The launch of formae, an innovative infrastructure-as-code tool, aims to tackle common challenges in cloud management, positioning itself as a potential game-changer in the DevOps landscape.
-
2510
AgentFold introduces a new way to manage context in LLM-based web agents, particularly for long-horizon tasks, improving performance through proactive context management, which can significantly benefit developers in various applications.
-
How to orchestrate agents using mission control
Exploring the concept of orchestrating AI agents through Mission Control, this episode delves into its significance in improving efficiency and collaboration in tech development. Hosts discuss the practical implications of this approach, highlighting real-world benefits and potential use cases.
-
Warp Embeds AI Agents into a CLI to Provide Better Feedback Loop DevOps
The integration of AI agents into command line interfaces (CLI) represents a significant shift in the way developers interact with coding tools. Warp Code’s approach aims to create a tighter feedback loop between developers and AI, enhancing code quality and enabling more efficient workflows. This discussion explores the implications of this innovation for DevOps teams and the broader coding community.
-
The Teacher Is the New Engineer Inside the Rise of AI Enablement And
The rise of AI enablement is reshaping the workforce, emphasizing the need for educators who can teach and guide AI tools rather than traditional engineering roles.
Dev ToolsNews -
New Memory Framework Builds AI Agents That Can Handle the Real Worlds
In this episode, we dive into a groundbreaking new memory framework that enhances AI agents' abilities to function in the real world, exploring its implications, potential applications, and how it might change our interaction with technology.
-
The New Pebble: Now 100% Open Source
The new Pebble smartwatch is now fully open-source, enabling users to modify and repair their devices. This move aims to provide longevity and customization in a landscape dominated by proprietary tech. Hosts explore its significance, potential user benefits, and future possibilities.
-
lYttNavMJN
:first-child]:h-full [&>:first-child]:w-full [&>:first-child]:mb-0 [&>:first-child]:rounded-[inherit] h-full w-full [&>:first-child]:overflow-hidden [&>:first-child]:max-h-full"> Go to ChatGPTCoding r/ChatGPTCoding • AdditionalWeb107 Italiano archgw (0.3.20) - Sometimes a small release is a big one ~500 MB of python deps gutted out. archgw (a models-native sidecar proxy for AI agents) offered two capabilities that required loading small LLMs in memory: guardrails to prevent jailbreak attempts, and function-calling for routing requests to the right downstream tool or agent.
-
Natural Language Visualization and the Future of Data Analysis and Presentation | Towards Data Science
Data Visualization Natural Language Visualization and the Future of Data Analysis and Presentation Will conversational interaction replace SQL queries, KPI reports, and dashboards? Michal Szudejko Nov 21, 2025 28 min read Share Photo by Claudio Schwarz on Unsplash For decades, data analysis has been like classical art.
-
GitHub Chen Zexi/open Ptc agent: An open source implementation of code execution with MCP (Programatic Tool Calling)
Open PTC Agent English | 中文 Getting Started | Demo Notebooks | Configuration | Changelog | Roadmap What is Programmatic Tool Calling? This project is an open source implementation of Anthropic recently introduced Programmatic Tool Calling (PTC) , which enables agents to invoke tools with code execution rather than making individual JSON tool calls.
-
GitHub Pguso/rag From scratch: Demystify RAG by building it from scratch. Local LLMs, no black boxes Real understanding of embeddings, vector search, retrieval, and context Augmented generation.
RAG from Scratch Demystify Retrieval-Augmented Generation (RAG) by building it yourself - step by step. No black boxes.
-
NFzcjna0zb
In today's episode, we explore how a developer uses Perplexity MCP as a secret weapon to enhance productivity with ChatGPT. We'll discuss the benefits of this approach, the cost-effectiveness, and the importance of using reliable sources.
-
8 platform engineering anti Patterns
Golden paths gone gray? Avoid these common mistakes that sink platform engineering initiatives.
-
8hlgNiDYjM
:first-child]:h-full [&>:first-child]:w-full [&>:first-child]:mb-0 [&>:first-child]:rounded-[inherit] h-full w-full [&>:first-child]:overflow-hidden [&>:first-child]:max-h-full"> Go to ChatGPTCoding r/ChatGPTCoding :first-child]:h-full [&>:first-child]:w-full [&>:first-child]:mb-0 [&>:first-child]:rounded-[inherit] h-full w-full [&>:first-child]:overflow-hidden [&>:first-child]:max-h-full"> r/ChatGPTCoding Welcome to our community! This subreddit focuses on the coding side of ChatGPT - from interactions you've had with it, to tips on using it, to posting full blown creations!
-
Building the Open Agent Ecosystem Together: Introducing OpenEnv
Back to Articles Building the Open Agent Ecosystem Together: Introducing OpenEnv Published October 23, 2025 Update on GitHub Upvote 127 +121 Joseph Spisak spisakjo Follow openenv Davide Testuggine darktex Follow guest Zach Wentz zkwentz Follow openenv Pierre Andrews mortimerp9 Follow openenv Sanyam Bhutani Sanyam Follow openenv Hamid Shojanazeri Hamid-Nazeri Follow openenv Pankit Thapar Pankit01 Follow openenv Emre Guven emre0 Follow openenv Lewis Tunstall lewtun Follow Vaibhav Srivastav reach-vb Follow The Problem The Solution The RFCs Use cases What’s Next With tools like TRL , TorchForge and verl , the open-source community has shown how to scale AI across complex compute infrastructure. But compute is only one side of the coin.
-
Deep Agents overview Docs by LangChain
Explore the capabilities of Deep Agents in LangChain, a powerful tool for building specialized agents capable of handling complex tasks with planning and context management.
-
LangChain and LangGraph Agent Frameworks Reach v1.0 Milestones
LangChain and LangGraph have released their first major versions, v1.0, focusing on agent flexibility, middleware, and improved model integrations, while ensuring stability and backward compatibility for developers.
-
Critical Vulnerability in MCP Server Platform Exposes 3,000+ Servers and Thousands of API Keys
Home Cyber Security Critical Vulnerability in MCP Server Platform Exposes 3,000+ Servers and Thousands of... Cyber Security Cyber Security News Vulnerability News Critical Vulnerability in MCP Server Platform Exposes 3,000+ Servers and Thousands of API Keys By Guru Baran - October 22, 2025 A critical vulnerability in Smithery.ai, a popular registry for Model Context Protocol (MCP) servers .
-
How to Use Frontier Vision LLMs: Qwen3 VL | Towards Data Science
Large Language Models How to Use Frontier Vision LLMs: Qwen3-VL Learn how you can use vision language models to perform advanced document understanding tasks. Eivind Kjosbakken Oct 20, 2025 11 min read Share Learn how to use vision LLMs.
-
Let’s Build the GPT Tokenizer: A Complete Guide to Tokenization in LLMs – fast
18 months ago, Andrej Karpathy set a challenge : “Can you take my 2h13m tokenizer video and translate the video into the format of a book chapter”. We’ve done it, and the chapter is below, including key pieces of code inlined, and images from the video at key points (hyperlinked to the video timestamp).
-
Nanochat Lets You Build Your Own Hackable LLM
Nanochat offers an accessible way to create your own customizable large language model, emphasizing user modification and experimentation.
-
Securing your agents with authentication and authorization
Securing your agents with authentication and authorization Agents can take action which makes proper authentication and authorization critical. Read on for how to implement and evolve agent auth.
-
Optimizing Coding Agent Rules (CLAUDE.md, agents.md, ./clinerules, .cursor/rules) for Improved Accuracy
Optimizing Coding Agent Rules (./clinerules) for Improved Accuracy Published October 14, 2025 Coding agents have become the focal point of modern software development. Tools like Cursor, Claude Code, Codex, Cline, Windsurf, Devin, and many more are revolutionalizing how engineers write and ship code.
-
JavaScript Library Runs Machine Learning Models in Browser
A new JavaScript library enables developers to run machine learning models directly in the browser, making AI more accessible and efficient.
-
Elena Verna at ProductCon: Why Traditional Product Management is Dying (And What to Do About It) PART 1 Just listened to Elena Verna's (Head of Growth at Lovable) talk at ProductCon, and it was a… | Anastasiia Moskovchenko
Anastasiia Moskovchenko Product Manager | AI/ML Products | 4x Growth at Yandex.Zen 1mo Report this post Elena Verna at ProductCon: Why Traditional Product Management is Dying (And What to Do About It) PART 1 Just listened to Elena Verna's (Head of Growth at Lovable) talk at ProductCon, and it was a wake-up call for anyone who thinks product management has stayed the same. Here's what's happening right now: 1.
-
We built our coding agent for Slack instead of the terminal
Mintlify Agent revolutionizes documentation management by integrating it with Slack, making the process of updating documentation feel seamless and less daunting for developers.
-
Continue.dev AI coding assistant
Continue.dev revolutionizes coding by automating repetitive tasks, allowing developers to focus on creative solutions. With its seamless integration in various environments and customizable workflows, it promises efficiency and adaptability in coding practices.
-
Doubling down on DeepAgents
In this episode, we dive into the exciting updates of LangChain's DeepAgents 0.2 release, exploring its new features, the importance of planning tools, and how it distinguishes itself from LangChain and LangGraph.
-
Chat in NotebookLM: A powerful, goal focused AI research partner
NotebookLM has received significant upgrades, enhancing its chat capabilities with a larger context window, improved memory, and personalized goal settings, making it an even more powerful AI research partner.
-
Building a Multimodal RAG That Responds with Text, Images, and Tables from Sources | Towards Data Science
Large Language Models Building a Multimodal RAG That Responds with Text, Images, and Tables from Sources Why do few chatbots return figures from source documents in their responses? Partha Sarkar Nov 3, 2025 11 min read Share Photo by Steve Johnson on Unsplash Retrieval-Augmented Generation (RAG) has been one of the earliest and most successful applications of Generative AI.
-
GPT 5 prompting guide | OpenAI Cookbook
Unlock the full potential of GPT-5 with practical prompting strategies to enhance performance and steerability.
-
I switched from LM Studio/Ollama to llama.cpp, and I absolutely love it
I switched from LM Studio/Ollama to llama.cpp, and I absolutely love it Credit: By Dhruv Bhutani Published Nov 2, 2025 Dhruv Bhutani has been writing about consumer technology since 2008, offering deep insights into the personal technology landscape through features and opinion pieces. He writes for XDA-Developers, where he focuses on topics like productivity, networking, self-hosting, and more.
-
A closer look at Python Workflows, now in beta
Cloudflare introduces Python Workflows in beta, expanding developers' ability to automate multi-step applications using Python, a favored language for data pipelines and AI. This new feature simplifies orchestration with built-in error handling and retry behavior, making it easier to create robust workflows.
-
eZ14meVrgl
:first-child]:h-full [&>:first-child]:w-full [&>:first-child]:mb-0 [&>:first-child]:rounded-[inherit] h-full w-full [&>:first-child]:overflow-hidden [&>:first-child]:max-h-full"> Go to webdev r/webdev :first-child]:h-full [&>:first-child]:w-full [&>:first-child]:mb-0 [&>:first-child]:rounded-[inherit] h-full w-full [&>:first-child]:overflow-hidden [&>:first-child]:max-h-full"> r/webdev A community dedicated to all things web development: both front-end and back-end. For more design-related questions, try /r/web_design.
-
GitHub Snapchat/Valdi: Valdi is a cross platform UI framework that delivers native performance without sacrificing developer velocity.
Valdi is Snapchat's cross-platform UI framework that offers native performance while enhancing developer productivity. It allows developers to write UI once in TypeScript, compiling directly to native views across iOS, Android, and macOS. With features like instant hot reload and deep native integration, Valdi aims to streamline the development process and improve application performance.
-
Deepagents Quickstarts
Explore the world of Deepagents, a powerful open-source agent harness designed for efficient task management and execution using advanced AI techniques. Learn about its built-in tools, middleware, and how to customize agents for specific workflows.
-
GPT 5.1 Prompting Guide | OpenAI Cookbook
Introduction GPT-5.1, our newest flagship model, is designed to balance intelligence and speed for a variety of agentic and coding tasks, while also introducing a new none reasoning mode for low-latency interactions. Building on the strengths of GPT-5, GPT-5.1 is better calibrated to prompt difficulty, consuming far fewer tokens on easy inputs and more efficiently handling challenging ones.
-
Configure MCP server access for your organization or enterprise GitHub Docs
GitHub Copilot / How-tos / Administer Copilot / Manage MCP usage / Configure MCP server access Configure MCP server access for your organization or enterprise You can configure an MCP registry URL and access control policy to determine which MCP servers developers can discover and use in supported IDEs with GitHub Copilot. Who can use this feature?
-
MCP Funnel/packages/commands at develop · chris Schra/mcp Funnel
In today's episode, we explore the mcp-funnel project, focusing on its command package and how it can streamline your development process. We’ll break down what it is, its features, and its potential impact on your workflows.
-
No OAuth Required: An MCP Client For AWS IAM
Dennis Traub for AWS Posted on Nov 18 • Edited on Nov 20 No OAuth Required: An MCP Client For AWS IAM # ai # agents # mcp # aws When Anthropic published the Model Context Protocol (MCP) , I immediately started experimenting with deployment options on AWS: First, I tried running MCP servers as AWS Lambda functions. A great solution in terms of simplicity and cost, but it also meant I had to manually manage session state across invocations.
-
LLM Visibility Alignment 464073
AI SEO » Article Alignment for LLM visibility is incredibly complex, but doable Published: November 18, 2025 at 2:29 pm Read Time: 23 minutes Published: Nov 18, 2025, 2:29 pm · 23 min read Share Written by Mordy Oberstein Edited by Willie Vitari Table of Contents Table of Contents LLMs expose brand misalignment instantly. Discover how inconsistent messaging raises costs, kills visibility, and what brands must do to realign and win in AI search.
Dev ToolsBlog -
Stumbling into AI: Part 6—I’ve been thinking about Agents and MCP all wrong
Ever tried to hammer a nail in with a potato? Nor me, but that’s what I’ve felt like I’ve been attempting to do when trying to really understand agents, as well as to come up with an example agent to build.