Domain
Dev Tools
412 episodes
-
2095402931721842694
Justy and Cody dig into a detailed how-to thread on building a one-person back office using Viktor, an AI employee that lives in Slack and Teams. The author's central argument: the gap between AI advice and AI-done-work is what keeps small teams small, and the fix is lane isolation — one agent, one job, a pinned identity file, and a human gate on anything that touches sends or money. Cody stress-tests the architecture; Justy zeroes in on who actually benefits.
-
2089274302617022464
Masonry and Eyre unpack Iron Giant’s argument that Claude agents aren’t dumb, they’re linear — depth is solved by self-correcting loops, width needs dependency-aware graph orchestration. They trace the generator-verifier pattern, Goodhart failures, and the four load-bearing pieces of a graph, then separate what Anthropic actually documents from what’s speculative, and debate where the pattern helps versus where it adds overhead.
-
The Multiplayer AI Manifesto
Edmund and Geffen dig into the Multiplayer AI Manifesto — a five-principle framework arguing that AI work has quietly regressed from collaborative to siloed, and that fixing it requires shared agent sessions, open-by-default work, and org-wide governance. They surface the Harvard Business School P&G data, Shopify's River infrastructure, Claude Tag, and the real security and permission problems that make this harder than it sounds.
-
Repo to Skill: Distilling GitHub Repositories Into AI4AI Skills
Repo-To-Skill introduces DisCo, a skill-distillation system that extracts operational knowledge from GitHub repositories and papers, packaging it as compact, verified skills that autonomous ML research agents can load on demand. The AREX-Skill Library contains 5,000+ skills from 1,000 repositories organized into 20 areas and 178 capability families. In matched tests with GPT-5.5 backbone and fixed execution budget, skill-equipped agents outperform skill-free baselines by 134.3% on MLE-bench, 34.4% on PaperBench, 9.2% on FrontierCS, and 14.0% on PassNet—gains purely from operational knowledge, not model or harness improvements.
-
4 engineering patterns behind the strongest AI Agents Challenge submissions Google Developers Blog
Google's post-Challenge analysis identifies four concrete engineering patterns that separated top submissions from the crowd: bidirectional MCP (agents serving tools both internally and to other agents), event-driven concurrency (agents reacting to shared signals in parallel instead of call chains), same-bar fallback (smaller models with the same validation gate as the primary), and tiered routing (cheap deterministic checks before expensive model calls). The central claim is that these aren't about bigger models or teams—they're sound engineering practices that are frequently overlooked, and they compose well together.
-
How Much Is a Token
Talon and Wildflower discuss the eroding utility of the 'token as a unit of economic value in AI, sparked by Anthropic's tokenizer changes and the rise of competitive open-weight inference providers.
-
Your LLM Can Return Perfect JSON and Still Be Wrong
A real-world trap in Structured Outputs: enforcing schema validity does not guarantee data truthfulness. When a required field is missing from source text, the model invents a plausible value instead of returning null, producing type-correct but false data. The fix requires three layers: nullable fields to allow absence, evidence fields to show provenance, and post-parse validators to catch nonsense values. The essay walks through a payment-reconciliation pipeline where 2–3% of transactions had fabricated dates, caught only downstream.
-
NVIDIA Brings Simplified Local AI Support To NVIDIA GPUs Carrying 24+ GB VRAM While vLLM & & llama.cpp Optimizations Boost Compute By Up To 1
NVIDIA ships kernel optimizations for local AI inference on RTX and DGX platforms, delivering up to 1.9x performance gains through vLLM and llama.cpp, paired with one-click agent setup (Perplexity Portable Computer, Hermes Agent, OpenClaw) for GPUs with 24+ GB VRAM. The move collapses the friction between local-first and cloud-capable workflows.
-
Overview: Dynamic Code Execution
We finally slow down and explain dynamic code execution from the ground up — what it actually is, how the loop works, why it makes models meaningfully more capable, and where the real costs and failure modes live.
-
Bringing Advanced Sampling to the OpenTelemetry Collector
Honeycomb is donating its adaptive tail sampling processor to OpenTelemetry, moving beyond rigid static rules toward dynamic, fingerprint-aware sampling that keeps rare traffic visible while capping costs. The key insight: trace fingerprinting plus logarithmic rate normalization lets you hit a throughput or percentage budget across heterogeneous traffic patterns without losing coverage of low-volume journeys.
-
FDE transforms enterprise AI deployment | VentureBeat
Onyx and Echo dig into the VentureBeat piece on forward-deployed engineering as enterprise AI's de facto context layer — whether FDE is a genuine product-learning loop or just expensive delivery labor that never compounds.
-
Agentic Skill Decay
Addy Osmani argues that agents can complete tasks so efficiently that junior engineers skip the learning reps that build real expertise—and that this 'skill decay' requires deliberate, proactive counter-measures. Deep expertise and applied judgment come from thousands of small failures and iterations; agents short-circuit that journey. An Anthropic study showed junior engineers using AI scored 50% on a Trio library quiz vs. 67% for those who worked by hand, with the AI group's wins concentrated among those who asked conceptual questions rather than treating the model as a code vending machine. The fix isn't to avoid agents but to use them as a teaching partner: form hypotheses before prompting, ask why, inspect diffs, predict failures, and stay in the loop so your mental model moves with the agent's work.
-
StarHarness: Evolving Harnesses with Stratified Search for Enterprise Environments
Edmund and Geffen dig into StarHarness, a ServiceNow and Mila paper that evolves agent harnesses — prompts, tool interfaces, skills, subagent structure — around a frozen model to close the gap between what an LLM can do and what a messy enterprise environment actually needs. Twenty to thirty-five percentage point gains across three benchmarks, and the harness transfers across GPT and Qwen model families without re-running the search.
-
OpenClaw 2.0 is here: What it means for enterprises
OpenClaw 2.0 (v2026.8.1) shipped over the weekend, pivoting from a personal developer agent to shared team infrastructure. The release redesigns the web UI around conversations, adds persistent multiplayer sessions, expands cloud execution, and hardens security with role-based permissions, sandboxing, and audit trails. For enterprises, this moves OpenClaw closer to an operational layer than a productivity app—but the security model requires careful deployment. Onyx sees a real product boundary shift; Echo flags that multiplayer doesn't automatically solve isolation, and the burden is on operators to configure it correctly.
-
Agent Hooks: An open, framework neutral AI governance contract
Pippa and Tyler dig into Microsoft’s Agent Hooks launch: an open governance contract meant to make agent controls enforceable, testable, and portable across frameworks instead of being framework-specific callback folklore.
-
Effective Patterns for Advanced MCP Usage – O’Reilly
Onyx and Echo break down an August 26 article that argues the Model Context Protocol’s power lies in stitching multiple servers into a single AI experience, exposing that mashup to many clients, and centralizing auth with an aggregator. They unpack concrete tools like mcp-auth-wrapper, mcp-aggregator, and mcp-install-instructions, weigh the benefits and pitfalls, and discuss who actually needs this in product and ops roles.
-
Orchestration is the new challenge for CX in the age of AI agents
Vince and Ava unpack a sponsored VentureBeat piece arguing that orchestration and shared context layers are now the main CX challenge in the age of AI agents. They separate legit architectural points—enterprise ontologies, context graphs, network latency—from marketing around Tata’s Interaction Fabric, and talk about who actually needs to care and what changes in practice for CX and IT teams.
-
Introducing Admin Plugin
Justy and Cody debate OpenAI's new Admin plugin for ChatGPT Work and Codex, weighing its practical value for workspace admins against the risk of smoothing over messy permission and governance edge cases.
-
Automating repetitive work at OpenAI with Codex
Draco and Asteria dig into an OpenAI engineer's blog post about using Codex with a tool called Runme to automate repetitive DevOps work — specifically running model evaluations and managing Kubernetes clusters. Draco's skeptical read: this is one person's workflow, not a generalizable system. Asteria pushes back on the receipts angle and what the notebook-as-artifact pattern actually unlocks at scale.
-
Ollama Claude Desktop Integration
Masonry and Eyre dig into Ollama’s Claude Desktop integration and whether making local models feel native inside Claude is a real product win or mostly a convenience layer. Eyre is wary of the framing; Masonry thinks the everyday workflow change is the point.
-
Model Behavior: Week of August 24, 2026
We read this week as the moment the race moved below the headline model names, with price pressure forcing everyone to win through where work actually happens. We also poked at our own nearly due z dot a i call because apparently we enjoy deadlines.
-
Apodex 1.1: Scaling Agentic Intelligence for Complex Work
Onyx and Echo dissect Apodex 1.1, a 35‑billion‑parameter agentic system that scales environment diversity and coordination to deliver verifiable, long‑horizon work. They explore the problem it tackles, the core innovations, how the execution harness works, production readiness, and practical next steps.
-
Graph Engineering in the Era of LLM Agents: From Individual Intelligence to System Intelligence
Pippa and Tyler dig into a survey arguing that once agent tasks need heterogeneous skills, parallel work, verification, and persistent state, the bottleneck stops being model quality and becomes coordination. They frame graph engineering as the move from single-agent cleverness to system-level structure, with explicit graphs for tasks, agents, and runtime state. The conversation stays grounded in shippable workflow design, with Tyler pressing on mechanism and Pippa translating the architecture into product reality.
-
Codex as a platform: build on the open agent harness | OpenAI Developers
OpenAI open-sources the Codex harness—the execution layer behind Codex app, CLI, and IDE extensions—so developers can embed agent loops into existing products instead of forcing users into a generic chat box. The harness handles context, tool use, approval flows, and sandboxing; developers control the interface, business logic, and integration. Real implementations already shipping: GitHub, JetBrains, Cisco, tax-prep workflows. Justy sees a product win (agent-native integration beats chat-box retrofit); Cody questions whether the harness abstraction actually reduces integration complexity or just moves friction around.
-
Vector RAG vs Graph RAG: Which Fits Best? | EM360Tech
Pippa and Tyler break down the real-world choice between Vector RAG and Graph RAG for enterprise AI: Vector RAG shines in straightforward retrieval but falters when the answer lives across relationships, while Graph RAG brings structure and richer answers—for a cost. The takeaway? Hybrid approaches are quietly becoming the practical default.
-
Claude Code
Onyx and Echo talk through Hazmat, an open-source containment layer for running Claude Code and other coding agents inside OS-level boundaries on macOS. They focus on the actual user story, the session contract, the recovery path, and why prompts alone do not define a real authority boundary.
-
SvelteKit 3 puts heat on Next.js with radical approach to RPCs
Vince and Ava dig into SvelteKit 3’s remote functions and the claim that they make the old page-loader and action patterns feel clunky. They focus on the practical win: type-safe client-to-server calls inside normal components, with less routing boilerplate and less reason to mark a whole page dynamic just for one live part. They also compare it to Next.js Server Functions, note the narrower write-focused design there, and land on the real question: whether this is a meaningful product simplification or just another RPC shape with a nicer coat of paint.
-
Stripe Payments Openrouter Singularity
Stripe says January 1, 2026 marked the beginning of a major technological and economic inflection point, using its business data as evidence. The more practical move may be its acquisition of OpenRouter, connecting model routing to the payments and control infrastructure Stripe already owns.
-
Model Behavior: Week of August 17, 2026
We read this week as a shift away from pure scoreboard chasing and toward whoever becomes the place work actually runs. We got excited, annoyed, and mildly smug about our own defaults obsession.
-
Snowflake adds AI model routing to cut costs | VentureBeat
Snowflake's new dynamic routing feature matters less as a cheap-model switcher than as a bid to make governed, auditable routing native to the enterprise data platform where a company already lives.
-
Nous Research Hermes Bot Mode
Hermes Bot Mode makes multi-agent coordination feel like a desktop product by turning existing Hermes profiles into named, persistent bots. Talon sees a real workflow win for small teams, while Wildflower likes the deliberately small technical design but warns that local profiles and inboxes are not a managed enterprise control plane.
-
I ditched Ollama as my default runtime, and the replacement starts models in a fraction of the time
Laura and Harper dig into an XDA piece arguing that BaseRT is a better default local runtime than Ollama on Apple Silicon because it reaches first token much faster, especially on long prompts. They agree the claim is real but narrow: BaseRT looks strong for Mac-first, performance-sensitive workflows, while Ollama still wins on breadth, compatibility, and convenience.
-
As enterprises confront AI agent sprawl, xpander wants them to own their own control and context layer
Wildflower pushes back on xpander’s claim to be the neutral control layer for enterprise agents, arguing the real question is portability of state and operations, not just model swapping. Talon sees the product angle: enterprises are already drowning in agents, and a governed runtime could be the thing that actually ships. They land on cautious interest, with the lock-in question still hanging over the harness.
-
DarwinX: Evolving Agent Harnesses Through Natural Selection
On DarwinX, Onyx and Echo dig into evolving agent harnesses via natural selection with frozen models, why path dependence and cross-task regressions have been killing self-improving agents, how DarwinX’s preserve-and-extend selection and archive actually work, what the numbers on Terminal-Bench, TerminalWorld, WebArena-Infinity, and SWE-bench Verified mean in practice, and whether this is research toy or something teams could realistically ship into their own agent stacks.
-
Why managed agents are the next big thing in agent building
Jessica and Cathy dig into Harrison Chase’s argument that “managed agents” are the next stage of agent building, where harness plus infra are bundled and driven by emerging standards like AGENTS dot md, MCP, and skills. They unpack what problems this actually solves in production, how LangChain’s Managed Deep Agents fits into their running harness-as-product thesis, where the piece is strongest, and what’s still underspecified.
-
DeepSeek open sources an agent harness where everything is a plugin
DeepSeek open-sources its agent harness — called dsh — under MIT, built on the Cordis meta-framework where the model adapter, tool registry, and agent loop are all swappable plugins. Justy and Cody dig into what the plugin-everything architecture actually means, who it's for, and whether this signals Chinese AI labs competing on infrastructure rather than just benchmarks.
-
AgentRadio boosts AI task accuracy by 92% | VentureBeat
Draco and Asteria dig into AgentRadio, a new async message-passing layer from Coral AI Labs that let four coordinating agents beat a single Claude Opus 4.8 on long-horizon codebase tasks. Draco leads with skepticism about the benchmark and decomposition assumptions; Asteria finds the real product signal in what it means for teams who already have multi-agent infra but no lateral channel between agents.
-
Introducing Delta Zed Blog
Pippa and Tyler dig into Delta, Zed's new private-beta multiplayer environment for agentic coding. They focus on its unusual core: DeltaDB keeps conversations and evolving worktrees synchronized alongside ordinary Git, making review, handoffs, cloud runs, and browser participation part of one shared thread.
-
2085024744387092973
Jessica and Cathy dig into a post that tries to boil Claude work down to agents, loops, and graphs. Cathy likes the structure but pushes back on the article’s tendency to make every layer sound universally useful, while Jessica argues the real win is that it gives people a practical ladder instead of vague agent hype.
-
2087163793558126997
Vince and Ava dig into a post arguing that Kimi Agent Swarm’s real trick is not 300 parallel agents by itself, but turning their outputs into a connected context graph that compounds over time. They test the claim against their running thesis about harnesses, receipts, and selective structure.
-
2080668775796314331
Justy and Cody examine the article’s argument that graph engineering is mainly about exposing real dependencies, parallelizing independent work, and adding independent verification. They like the practical core but question the article’s broader claims about speed, graph reliability, and the novelty of the label.
-
MCP Goes Stateless, and Developers Ask Whether That Just Makes It an API Again
MCP's July 28, 2026 release strips away protocol sessions and stateful handshakes, moving to a fully stateless architecture with metadata pushed into HTTP headers. The shift solves real scaling problems—load balancing, autoscaling, session migration—but it also reveals what MCP actually is: a REST API with a JSON-RPC convention on top and an auth layer below. The community is split not on whether statelessness is better, but on whether the protocol needed to exist at all once you've peeled back to REST plus headers.
-
Anthropic recommends a git worktree per agent. Your runtime infra makes that a problem.
Anthropic recommends a git worktree per agent for parallel coding sessions — Boris Cherny called it the single biggest productivity unlock. The article argues the pattern is sound but your runtime infrastructure (databases, caches, shared services) turns isolated branches into a coordination nightmare. Vince and Ava land on the same insight they've been tracking since ep 770: the architecture has to match the task shape, and worktrees solve the git problem while creating a new one at the runtime layer.
-
The throughput trap: AI Powered teams ship more code but deliver less
Masonry and Eyre unpack the LeadDev piece on the throughput trap: AI can flood teams with code, but the real bottlenecks move into review, testing, integration, and maintenance. They connect it to their long-running receipts-and-harness thread, joke about tokenmaxxing, and land on the idea that teams should measure the path to customer value, not just output.
-
Model Behavior: Week of August 10, 2026
We argue this week is about who owns the AI control plane, not who tops a leaderboard, and we use Cloudflare, LangSmith, Moshi, Anthropic, and the new open-model policy split as our evidence. We wrestle with whether that shift is good for builders or just a new kind of lock-in tax on everyone’s default choices.
-
Unifying Workers AI and AI Gateway into a single AI control plane
Pippa and Tyler dig into Cloudflare’s move to unify Workers AI and AI Gateway into one AI control plane, arguing over whether it’s a real simplification for developers or mostly a packaging move around the same underlying routing and billing layer. They land on it being genuinely useful if you already live in Cloudflare’s ecosystem, but not magically solving the hard parts of model choice, observability, or provider lock-in.
-
Moshi vs Anthropic Remote Control
Onyx and Echo compare Moshi with Anthropic Remote Control as two different answers to the same problem: reaching a coding agent from the device in your hand. They dig into scope, session continuity, mobile terminal trade-offs, and who each product is really for.
-
Managed Deep Agents is now in public beta
Jessica and Cathy discuss LangSmith Managed Deep Agents entering public beta, exploring its value for shipping agents without managing infrastructure, its open-source harness, and how it fits into the broader agent landscape including Anthropic's competing offering.
-
Meta Superintelligence Labs Releases Muse Code
Vince and Ava dig into Meta’s new Muse Code terminal coding agent and Muse Spark 1.2: are the persistent agents and replayable event log real developer wins or just more agent hype?
-
Pi, Minimal and Performant | EARENDIL
Tyler and Pippa dig into Pi, the minimal coding harness from Earendil, and the Databricks benchmark that claims simple harnesses beat bloated ones on real-world tasks. Tyler's skeptical about how much of this is genuine insight versus flattering a tool that happens to match a particular workload; Pippa thinks the cost-per-task framing is the actual product story and the Shopify autoresearch numbers are hard to dismiss.
-
The Agent Development Lifecycle has arrived on Cloudflare
Jessica and Cathy dig into Cloudflare packaging the messy agent workflow into something that looks a lot more like a real software lifecycle: building, tracing, testing, deploying, and maintaining agents on Workers with observability and workflow plumbing that already exists.
-
Coding Agents Don’t Need Bigger Context Windows — They Need a Context Compiler | Towards Data Science
Fern and Lintel dig into the article's claim that coding agents need smarter context pruning, not bigger context windows. They break down the mechanics of context compilation, how it slashes prompt bloat, and whether this shift changes the real product story for code AI. Along the way, they tease each other's optimism and skepticism, call back to their running jokes about infrastructure, and reflect on the broader context engineering debate.
-
Your agent needs a computer, not a container — introducing @cloudflare/computer
Auden and Wren dig into Cloudflare’s early preview of @cloudflare/computer, a new agent runtime that gives each agent its own computer rather than a bare container. They focus on the user story, what’s actually new, and where the abstraction looks genuinely useful versus a little hand-wavy.
-
Stop graphing everything: When GraphRAG actually beats vector RAG
Pippa and Tyler dig into a fresh GraphRAG piece that argues graphs only beat vector RAG when the question needs multi-hop reasoning, global sensemaking, or summary across an interconnected corpus. They walk through the mechanism, the benchmark evidence, the cost caveat, and the practical hybrid answer without pretending graphing everything is the move.
-
Infrastructure patterns for agentic applications
Justy and Cody unpack why naive HTTP‑wrapped AI agents break in production and walk through three infrastructure patterns—web‑queue‑worker, workflow engines, and a hybrid approach—highlighting idempotency, compensation, and real‑world product impact on teams building long‑running agents.
-
Deep Agents v0
Deep Agents v0.7 ships a sixty-five percent token reduction by stripping the base system prompt, trimming tool descriptions, and making TodoListMiddleware opt-in — Masonry and Eyre dig into what the harness-gets-simpler pattern actually means in practice, where the Sonnet cost anomaly is a warning sign, and why configurability was the real missing piece.
-
Advanced Context Engineering for Coding Agents/benchmarking Opus 5 on Slop Code Bench.md at main · humanlayer/advanced Context Engineering for Coding Agents
Vince and Ava dig into a hands-on benchmark run from the HumanLayer repo — Opus 5, Opus 4.8, and Sonnet 5 put through SlopCodeBench, a checkpoint-based coding benchmark from UW Madison that withholds requirements iteratively. Opus 5 wins technically at 24% strict pass rate, but nobody finished clean, and the code quality metrics tell a story about how models degrade over long-horizon tasks.
-
Early Adoption of Agentic Coding Tools by GitHub Projects
Asteria and Draco analyze a GitHub study of 25,264 agentic pull requests across 2,361 repositories, finding that while agentic coding tools are spreading, real adoption remains thin: median repos generate only 1-2 agent PRs per quarter, small teams use them more intensively than large ones, and nearly all projects rely on a single human reviewer to oversee agent work. The paper reveals adoption is infrastructure-constrained, not capability-constrained — the bottleneck is human oversight capacity and project governance, not what the agents can generate.
-
CodeNib: A Multi View Data System for Serving Repository Context to Coding Agents
CodeNib is a multi-view data system that treats repository context as a data-systems problem: build lexical, dense, and structural views once per commit, maintain each through its own path (graph repair, vector reuse), and serve them to coding agents through ranked retrieval, static navigation, and bounded context policies. The paper reports 8.7× speedup on graph updates and 25.4× on vector updates when outputs match rebuilds, static navigation reproducing live-server paths on 63% of requests, and 50–87% fewer tokens in agent trajectories vs. grep/read. The core insight is that repository context shouldn't collapse into one abstraction—heterogeneous views need independent physical layouts, update paths, and delivery contracts, with explicit cost visibility across the agent lifecycle.
-
The harness is all you need (mostly)
Burke Holland argues that productivity gains with AI come not from exotic prompts or new tools, but from deeply understanding and using the harness well. He walks through a concrete six-step workflow (pick a tool, enable autonomy, prototype, plan, implement with Autopilot, iterate) that leverages GitHub Copilot's built-in orchestration and subagent routing without requiring custom skills or tricks. The central claim is that the harness — the core interaction model — is what matters; everything else is noise.
-
GitHub Nolabs ai/nono: Sandbox any AI agent in seconds Zero setup, zero latency.
nono is an open-source sandbox for AI agents that runs with zero latency, zero setup, and zero disk overhead — no daemon, no container, no VM. Built by the Sigstore team, it enforces least-privilege sandboxing at the kernel level, supports popular agents (Claude Code, Codex, CoPilot, etc.), and innovates on tool-level isolation: when an agent calls a tool like git or gh, that tool runs in its own child sandbox with separate policies, credentials, and network rules. The registry has migrated from always-further to nolabs-ai, and a 1.0 release is in the lead-up. Jessica sees product fit and adoption velocity; Cathy probes the sandboxing guarantees and whether the policy complexity scales.
-
I ditched Ollama for Docker, and my local LLM setup finally stopped being a hassle
Onyx and Echo dig into a developer's migration from Ollama to Docker Model Runner — unpacking why it's a genuine workflow win for Docker-native teams, where Ollama still wins, and what the multi-backend story actually means for local LLM setups.
-
A New Role for Relevance: Guiding Corpus Interaction in Agentic Search
Tencent and IIE-CAS researchers introduce RARG, a Relevance-Aware RipGrep Search Agent that turns document relevance scores into an execution priority for grep-style corpus search — ordering which files get scanned first, seeding the agent with relevant entry-point paragraphs, and reranking raw match output so the most informative excerpts survive truncation. On BrowseComp-Plus the system hits 84% accuracy with GPT-5.4-mini using 23.9 average tool calls versus 99.1 for vanilla Direct Corpus Interaction, and scales to 1M documents retaining 79% accuracy where RISE drops to 69%.
-
The 2026 07 28 MCP Specification Release Candidate
Miles leads a skeptic's take on the MCP 2026-07-28 release candidate — the biggest protocol overhaul since launch. Stateless core, extensions framework, Tasks redesign, and authorization hardening all land today. Miles is genuinely impressed by the infrastructure work but skeptical about the migration burden on teams who shipped against the old spec. Cooper pushes back on whether the pain is real or just spec-update noise.
-
Overview: Directed Acyclic Graph
We finally slow down on directed acyclic graphs, or D A Gs, because this one quiet structure keeps showing up under workflows, agents, build systems, and half our control-stack arguments. We make it click as a map of prerequisites: arrows for order, no loops, and a scheduler that can see what can run now.
-
The new rules of context engineering for Claude 5 generation models | Claude by Anthropic
Anthropic's post on context engineering for Claude 5 models reveals a surprising finding: they removed over 80% of Claude Code's system prompt with no measurable loss in performance. The core insight is that newer models need fewer explicit constraints and benefit more from clean interfaces, progressive disclosure, and letting the model use judgment rather than following hard rules. The shift reflects a broader pattern: as models get stronger, the infrastructure around them gets simpler.
-
"Developers see this as the future": Pilot Protocol launches to power the agent economy
Pilot Protocol launches as an overlay network for agent-to-agent communication, hitting 16,000 agents in 24 hours with $4.5M seed funding. The platform addresses a real infrastructure gap: agents need discovery, trust, and reliable routing the way the early web needed DNS and TCP/IP. Pippa sees immediate product fit; Tyler digs into whether the routing and verification actually hold up under load.
-
Graph Based Agentic AI with LangGraph: Workflow Pathways for Long Running Stateful Business Processes
Cooper and Miles dig into a practitioner paper on LangGraph as a control-plane for long-running business workflows, not a benchmark toy. They focus on the three recipes in the paper—SQL repair loops, evidence-gated RAG, and human-in-the-loop policy review—and on when a graph is actually worth the extra structure.
-
2078778799064584535
A viral claim that Graph Engineering has displaced RAG at major AI labs, and what that actually means in practice.
-
eve – The Agent Framework Vercel
Jessica and Cathy dig into Vercel's eve, a filesystem-first framework for durable AI agents, and why its boring production defaults may matter more than the agent hype around it.
-
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.
-
How to Apply Professional Design Principles in AI App Development
Vince and Ava dig into Expo’s design post about why vibe-coded apps all blur together, and why a simple visual checklist might be more useful than one more magic prompt. They like the practical vocabulary: contrast, hierarchy, alignment, proximity, repetition, balance, white space, and unity. Vince sees a real product win for developers who can finally critique AI UI output without becoming designers overnight. Ava buys the framing too, with the caveat that screenshots and iterative critique matter because the model still can’t actually see design the way a human does.
-
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.
-
Encoder Free VLM a Hugging Face Space by HuggingFaceM4
A Hugging Face Space for an encoder-free vision-language model is still loading its metadata, making the live demo itself the clearest place to inspect the project.
-
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.
-
Introducing Observe
Masonry and Eyre discuss Expo's launch of EAS Observe — production performance monitoring for React Native apps that fills the gap between dev-time debugging tools and crash reporters. They dig into the specific metrics, the agent-first design philosophy, and the GA-to-paid pricing transition happening August 20, 2026.
-
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.