Domain
Agents
374 episodes
-
MCP server portals
Asteria and Draco unpack Cloudflare's MCP server portals as boundary infrastructure for enterprise MCP adoption: one Access-controlled endpoint, curated tools, managed OAuth, Code Mode, and observability, with caveats around direct server URLs, admin credentials, and sync paths.
-
Introducing Claude Opus 5
Anthropic ships Claude Opus 5 — a model that hits near-Fable-5 performance on coding and knowledge work benchmarks at roughly half the cost per task. Onyx and Echo dig into what the numbers actually mean, who it's for, and whether the effort-level dial is the sleeper feature nobody's talking about.
-
AREX: Towards a Recursively Self Improving Agent for Deep Research
Pippa and Tyler dig into AREX, a recursively self-improving deep research agent from BAAI that alternates between an inner search loop and an outer constraint-verification loop — and discuss whether that architecture is genuinely novel or a smarter repackaging of ideas the field already had.
-
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.
-
2080056638820450400
A post about Buzz points to a core requirement for trusted agents: cryptographic identity, human binding, and auditability.
-
Towards a Science of Scaling Agent Systems
Onyx and Echo examine “Towards a Science of Scaling Agent Systems,” a controlled study of when multi-agent architectures help, when coordination becomes a liability, and why task structure matters more than simply adding agents.
-
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.
-
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.
-
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.
-
Meta Harness: End to End Optimization of Model Harnesses
Meta-Harness automates harness engineering by using a coding agent to search over harness code, giving it full access to prior execution traces and scores via a filesystem rather than compressed summaries. On text classification, it improves 7.7 points over prior systems while using 4× fewer context tokens; on math reasoning, a single discovered harness improves IMO-level problems by 4.7 points; on TerminalBench-2, it ranks #1 for Claude Haiku 4.5 agents. The core insight is that harnesses operate over long horizons—a single retrieval or storage choice affects behavior many steps later—so rich, adaptive access to full diagnostic history beats compressed feedback.
-
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.
-
To Every Agent Its Own Database
Jessica and Cathy dig into Joe Reis’s argument that agentic data systems should flip the warehouse model: give each agent its own embedded analytical engine, then exchange immutable slices peer-to-peer instead of routing everything through one shared platform. They focus on why that matters for concurrency, freshness, and trust, and where the idea still needs real control-plane machinery.
-
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.
-
Overview: Model Routing
We finally pin down model routing, because we throw the term around all the time and somehow never actually define it. We walk through how a router sends each request to the model most likely to handle it well, and why that can save cost, latency, and a lot of dumb overgeneralization.
-
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.
-
In a world of AI agents, where do we fit in?
Justy and Cody dig into a New Stack piece on human purpose in an agentic world — what does it mean to stay relevant when agents handle the work? The article argues the real value shifts from execution to judgment, oversight, and the decisions that matter. Cody probes the technical claim (agents still need human signal loops), Justy maps it to product adoption (teams that skip the oversight layer ship broken stuff). They land on a shared insight: the boring infrastructure — audit trails, decision boundaries, human-in-the-loop gates — is exactly where the product surface lives now.
-
EvolvingWorld: An Open Schema Framework for Co Evolving Role Play Agents and World Model in Interactive Literary World
Masonry and Eyre dig into EvolvingWorld, a new framework that lets fictional characters and their world co-evolve across long stories. Eyre walks through the open-schema architecture and seven supervised tasks; Masonry sizes up who would actually build with this and where product pain lives. The hosts end up excited about the open-schema premise but skeptical of the benchmark’s generality.
-
Cursor Codex Gemini CLI Antigravity Hit by Sandbox Escapes
Vince and Ava dig into the sandbox-escape report on Cursor, Codex, Gemini CLI, and Antigravity, focusing on why these agent tools are only as safe as the host tools they can trick into running. They connect the issue to real adoption pressure, the fragile trust boundary around file writes, and the fact that sandboxing is becoming a product feature, not a nice-to-have.
-
Seed: Self Evolving On Policy Distillation for Agentic Reinforcement Learning
Seed tackles the credit-assignment problem in long-horizon agent reinforcement learning by turning completed trajectories into evolving natural-language hindsight skills, then distilling their effect into dense token-level training signals. Vince sees a potentially shippable training pattern for teams already running agentic RL; Ava likes the on-policy design but wants stronger evidence that self-generated skills do not amplify the model’s own blind spots.
-
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.
-
Tracing Agentic Failure from the Flow of Success
Jessica and Cathy dig into Oat, a lightweight unsupervised failure-attribution model for agentic systems that learns only from successful trajectories. They unpack why the paper matters for debugging long-horizon agents, how Neural CDEs and a gated control path turn success traces into a normal-flow model, and why the speed and no-label setup make it feel more shippable than prompt-heavy baselines.
-
Why every AI agent decision needs a receipt
Two hosts dig into the case for giving every AI agent action a receipt: not because logs are fashionable, but because verification is the only way to know what happened, what failed, and what to trust. They stay skeptical about overgeneralizing, but land on a practical view that evidence packets matter most where agent decisions touch code, runtime, or anything expensive to undo.
-
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.
-
Better tools made Copilot code review worse. Here's how we actually improved it.
Pippa and Tyler dig into GitHub’s post on why giving Copilot code review better tools actually regressed its performance—and how rewriting tool instructions for a reviewer’s workflow flipped the regression into a 20% cost win without losing review quality.
-
How to Implement a Unified Memory From Scratch
Jessica and Cathy dig into a new post that walks through building a unified agent memory from scratch using knowledge graphs and MongoDB, unpacking what it actually takes to wire memory into a real agent harness. They tease apart where the post’s blueprint shines, where it overreaches, and who on earth should actually roll their own instead of reaching for an off-the-shelf tool.
-
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.
-
Stripe Benchmark Shows AI Agents Build Integrations but Struggle with Validation
Cathy is skeptical that the Stripe benchmark proves much beyond a familiar split: agents can write integration code, but they still get tripped up by validation, state, and recovery. Jessica thinks that’s exactly the useful part, because in real product work the hard failure is often whether the thing can prove it worked, not whether it can type out the API calls.
-
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.
-
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.
-
Stanford Researchers Introduce TRACE: A Capability Targeted Agentic Training System That Turns Recurrent Agent Failures Into Synthetic RL Environment
Stanford's TRACE system converts recurring agent failures into targeted synthetic training environments, using LoRA experts and MoE routing to close specific capability gaps without retraining the whole model.
-
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.
-
Long Horizon Terminal Bench: Testing the Limits of Agents on Long Horizon Terminal Tasks with Dense Reward Based Grading
Laura and Harper dig into Long-Horizon-Terminal-Bench, a new benchmark exposing the gap between short-task agent demos and real multi-hour workflows. They break down the dense-reward grading system, the staggering token costs (9.9M per task), and why current models are failing at sustained execution despite high step-level competence.
-
Agentic Testing: Where Agents Fit in the E2E Testing Stack
Slack's Sergii Gorbachov ran 200+ agentic E2E tests to measure where agent-driven testing fits alongside traditional deterministic tests. Core finding: agents verify goals (adaptable paths to the same outcome), while traditional tests enforce journeys (single deterministic sequence). MCP-based agents were most reliable (0% on simple flows, ~12% on complex); generated tests were fastest (~3 min) but fragile on complexity (~48% failure rate on harder flows); cost was the real constraint ($15–30 per run). The insight is not replacement—it's complementary layers. Agents excel at exploratory validation and catching UI state variability; deterministic tests handle regression and CI speed.
-
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.
-
Improving Agents is a Data Mining Problem
Laura and Harper dig into Vivek Trivedy's claim that improving agents is fundamentally a data-mining problem, unpacking what that means for continual learning, harness engineering, and who should actually care.
-
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.
-
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.
-
GPT 5 6
Talon and Wildflower dig into OpenAI’s GPT-5.6 launch and end up treating it less like a pure model release and more like a pricing-and-harness claim wrapped in benchmark flexing. Wildflower’s skeptical read is that the article keeps collapsing model quality, multi-agent orchestration, and product packaging into one victory lap. Talon pushes back that the practical story is real if Sol, Terra, and Luna actually move the cost-performance frontier for coding and knowledge work. They land on a calibrated view: the coding gains look more credible than the broad ‘best collaborator’ language, Terra may be the sleeper product, and ultra is interesting but shouldn’t be mistaken for a single-model breakthrough.
-
Nex N2 mini: A 35B Model Built for Autonomous Agents | HackerNoon
Exploring the Nex-N2-mini, a 35B-parameter open-source agentic language model designed for autonomous agents and complex tasks.
-
Tuning the harness, not the model: a Nemotron 3 Ultra playbook
A LangChain/NVIDIA case study claims harness tuning alone can push Nemotron 3 Ultra to 0.86 on Deep Agents at ~$4.48/run vs $43.48 for Opus 4.8, with parity latency. The hosts parse the real mechanism (matched scaffolding vs post-training), test limits (where harness hits a ceiling), and weigh who actually benefits. They surface concrete repos (langchain-ai/deepagents, langchain-ai/deepagentsjs) and a vendor profile workflow, then poke at the article’s reliance on Deep Agents and the cost math. Final take: a plausible win for teams already deep into harness work, not a universal unlock, with the hosts pushing back on ‘ten-x cheaper’ framing and under-specified benchmark footnotes.
-
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.
-
Overview: Agentic loops
We’re finally doing the overdue deep dive on agentic loops, the repeated observe-decide-act-observe cycle that makes AI systems feel like they’re actually working a problem instead of just answering once. We keep circling this idea, so we’re unpacking the mechanism, the trade-offs, and why it matters in practice.
-
SpaceXAI releases Grok 4.5, which Elon describes as an 'Opus class model' | TechCrunch
SpaceXAI unveils Grok 4.5 as an Opus-class model, touting two-times token efficiency and lower prices than Anthropic's Opus 4.7 and OpenAI's GPT 5.6 Luna. Fern sees a practical play for cost-sensitive users and asks if the agentic training on Cursor really changes anything. Lintel digs into the benchmarks and pricing math, pushing back on how much the claims actually hold up without hands-on testing.
-
I built Andrej Karpathy's "LLM Council" on my own hardware, and now no single model gets the last word
Jessica and Cathy dig into a local rebuild of Karpathy's LLM Council and land on the real claim: the win is not voting, it's structured synthesis across models with different failure modes. They like the practical adaptation to Ollama on a single twelve-gigabyte GPU, but push on where the article overreaches and where the product value is actually real.
-
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.
-
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.
-
Measuring the Gap Between Human and LLM Research Ideas
Cooper and Miles dig into a study that literally measures how much LLMs' research ideas diverge from humans' by reconstructing literature contexts and running comparative idea generation. They walk through the two-axis 'research-taste' taxonomy, the paper's finding that model outputs skew toward synthesis and bridge-building at the expense of broader human distributions, and what it implies for AI-scientist stacks. Ends up bullish on this line of work for aligning LLM ideation tools.
-
(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.
-
Viability of local models for coding
Birgitta Böckeler tests local LLM viability for coding after a year away from the space. She maps a complex web of factors—RAM, model size, quantization, tool calling, context windows, reasoning modes—that determine whether small models actually work for agentic coding on consumer hardware (M3 Max / M5 Pro). Her core finding: locals are runneable and faster than a year ago, but tool calling is still shaky, reasoning can backfire, and quality is hit-or-miss. She's not claiming local models are ready to replace cloud APIs; she's charting what actually works and what doesn't on real machines.
-
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.
-
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.
-
How to Use RLMs in Deep Agents
Exploring Recursive Language Models (RLMs) and their implementation in Deep Agents for handling long contexts efficiently.
-
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.
-
Introducing Claude Sonnet 5
Onyx and Echo unpack Claude Sonnet 5's launch, digging into the cost-performance curves that make it a potential default for agentic work, the safety tradeoff where it's safer than Sonnet 4.6 but less aligned than Opus 4.8, and whether 'agentic Sonnet' actually changes what teams ship or just shifts the price point.
-
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.
-
Reward hacking is swamping model intelligence gains · Cursor
Pippa and Tyler dig into Cursor's claim that coding benchmark gains are being inflated by runtime answer retrieval, not pure model intelligence. They land on the real argument: for historical public-repo evals, the harness is part of the benchmark, because open web and git history can leak the fix and change what the score means.
-
AI agent memory: MRAgent cuts token use up to 27x | VentureBeat
MRAgent from NUS replaces static retrieve-then-reason memory with active reconstruction during reasoning, cutting token use 27x over competing frameworks. The system treats memory as an interactive graph where agents dynamically refine retrieval paths based on intermediate evidence, using a three-layer Cue-Tag-Content structure and automated ingestion pipelines.
-
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.
-
Evaluating performance and efficiency of the GitHub Copilot agentic harness across models and tasks
GitHub Copilot's agentic harness is a single cross-experience SDK component that orchestrates tools, context, and workflow across CLI, app, and code review. The team claims it delivers task-resolution parity with model-vendor harnesses while cutting token usage across several configurations, backed by public and internal benchmarks and real-world metrics. We debate technical validity, practical stakes for teams, and whether the harness should get most of the credit.
-
How agents are transforming work
The article discusses how agents, specifically OpenAI's Codex, are transforming work by enabling long-horizon tasks and changing the unit of knowledge work from single interactions to delegated tasks.
-
HarnessX rewrites AI scaffolding mid task | VentureBeat
Xiaomi's HarnessX treats AI agent scaffolding as a first-class, modular object that can evolve mid-task without changing the underlying model. A trace-driven RL engine (AEGIS) automatically rewrites harness components—prompts, tool integrations, memory, control flow—while safeguarding against reward hacking and catastrophic forgetting. When paired with model fine-tuning on execution data (cross-harness GRPO), smaller models like Qwen3.5-9B see +44% gains on embodied planning, suggesting harness engineering, not just model scale, is the real bottleneck for enterprise agents.
-
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.
-
Qwen AgentWorld: Language World Models for General Agents
Justy and Cody dig into Qwen-AgentWorld, a new language world model that simulates seven agent environments. Cody breaks down the three-stage training pipeline (CPT, SFT, RL) and explains why a world model is the missing piece in agent development. Justy connects it to product reality: who ships this, what it actually unlocks, and whether it’s ready beyond the paper. They finish with cautious excitement and a quick Build Next check-in.
-
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.
-
Rethinking cloud operations with agentic observability The Official Microsoft Blog
Microsoft's Azure Copilot Observability Agent aims to revolutionize cloud operations with agentic observability, providing a connected view across signals to help operators manage complex, dynamic environments.
-
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.
-
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.
-
Agentic Rl
Cameron Wolfe's 'Agentic RL' argues that training LLMs for agentic work requires shifting from single-turn reasoning to multi-turn trajectory optimization, where the harness (tools, environment, memory) becomes part of the RL loop itself. The central claim is that standard post-training methods fail on long-horizon tasks because they don't account for environment state changes across steps, necessitating new rollout infrastructures and stability techniques like PPO over GRPO for variable-length traces.
-
WorldLines: Benchmarking and Modeling Long Horizon Stateful Embodied Agents
WorldLines (HKUST team) ships a benchmark + model (ObsMem) for long-horizon home robots that must remember daily routines, unseen state changes, and fix mistakes over days. Cody digs into how the observer-grounded memory keeps world state coherent under partial observability and where it still stumbles. Justy sizes who actually builds with it and what shipping looks like.
-
"An agent is an LLM and a harness": What Nvidia really thinks about OpenClaw
Nvidia’s OpenClaw take frames agents as ‘LLM + harness’ and shows how blueprints guide engineering choices. Justy sees a pragmatic push for tooling consistency; Cody questions whether this collapses the harness into vendor lock-in and whether the blueprint abstraction hides real variability.
-
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.
-
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.
-
AI optimizer beats Claude Code, Codex by 2
Researchers introduce Arbor, a framework that structures AI optimization as a cumulative learning tree instead of isolated trial-and-error loops, delivering 2.5x verifiable gains over Claude Code and Codex on the same compute. It solves the core AO bottleneck: agents forgetting what they’ve learned across long-running experiments.
-
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.
-
Beyond Alignment: Value Diversity as a Collective Property in Multicultural Agent Systems
A research paper from Singapore University of Technology and Design and Washington University in St. Louis introduces 'value diversity' as a system-level evaluation metric for multicultural multi-agent systems. The core finding: existing LLM-based agent systems are systematically less diverse than human societies and show almost no correlation between per-agent cultural alignment and system-wide value heterogeneity. Single-backbone systems fall far short of human diversity levels (36.12 vs. 44.07); mixed-backbone configurations help but don't close the gap; and social interaction between agents drives homogenization rather than preserving plurality. The paper uses the World Values Survey across 19 cultures and 18 models, includes a participatory budgeting case study, and releases code and datasets.
-
Stanford's DeLM cuts multi Agent costs 50%
Justy and Cody dissect Stanford's DeLM framework, which claims to halve multi‑agent costs by removing a central orchestrator. They weigh the technical merits, practical impact for product teams, and the hidden scheduling trade‑offs.
-
4 Ways We’re Using Our MCP Server at Figma | Figma Blog
Justy and Cody dig into Figma's Model‑Context‑Protocol server, unpacking how it lets AI agents edit slides and FigJam boards directly, why custom‑font and asset tools matter, and what real‑world designers should care about.
-
Just Shipped: Flue 1.0 Beta Flue is the TypeScript framework for building the next generation of agents, designed ar...
This brief covers the launch of Flue 1.0 Beta, a TypeScript agent framework with zero LLM lock-in built on Astro-like principles, its three core primitives, and how to test it today.
-
Akshay 🚀 (@akshay pachaar) on X
Justy and Cody unpack Akshay Pachaar’s claim that the real product is the harness around the model, not the model call itself. They focus on orchestration loops, tool boundaries, memory, and context management as the parts that make agent systems usable, while Cody pushes on where harness talk can get vague.
-
Aatish Nayak (@nayakkayak) on X
Justy and Cody push back on the 'collaborative intelligence' framing — the claim that AI works solo but fails at organizations — and debate whether the real gap is social plumbing or just better context sharing.
-
Sydney Runkle (@sydneyrunkle) on X
Sydney Runkle's 'The Art of Loop Engineering' argues that reliable agents aren't built by picking a smarter model — they're built by tightening the loop around the model. Justy sees the product case for treating loops as the actual unit of engineering; Cody is skeptical that any single taxonomy survives contact with real systems. They land somewhere between: useful framing, not a recipe.
-
Lakeflow New Era Agentic Data Engineering
Databricks' Lakeflow introduces agentic data engineering: AI-driven pipeline development, ZeroOps automation, 100+ connectors, Kafka-free ingestion, and real-time Spark pipelines. The core claim is that AI can handle data pipeline maintenance and optimization, reducing operational overhead.
-
Building a 100x Cheaper Trace Judge with Fireworks
LangChain Labs and Fireworks built a fine-tuned Qwen model to detect 'perceived error' in production agent traces—matching frontier performance at up to 100x lower cost. The model judges user-visible mistakes (corrections, rejections, repeats) from human-AI messages only, tested across two internal datasets (chat-langchain Docs Q&A and Fleet no-code agents).
-
When is Your LLM Steerable?
A new paper investigates whether you can predict if a steering attempt will succeed by looking at the model's hidden states from just the first few tokens—before decoding the full response. The authors build ASTEER, a dataset of 1.4M steered generations labeled for success/failure across 150 concepts, then train a GBDT classifier on early hidden-state features to predict three outcomes: under-steer, success, or over-steer. The predictor hits ~0.7 macro-F1 on unseen concepts and cuts the cost of finding good steering strengths without expensive full rollouts.
-
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.
-
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.
-
Nemotron 3 Ultra: Open, Efficient Mixture of Experts Hybrid Mamba Transformer Model for Agentic Reasoning
Nemotron 3 Ultra is NVIDIA's 550B-parameter Mixture-of-Experts hybrid Mamba-Attention model with 55B active parameters per token, pre-trained on 20 trillion tokens and extended to 1M context. It achieves 6× higher inference throughput than comparable open models while maintaining on-par accuracy, using LatentMoE, Multi-Token Prediction, NVFP4 low-precision training, and multi-teacher on-policy distillation. The entire model, training recipes, and datasets are open-sourced on HuggingFace.
-
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.
-
Z.ai Launches GLM 5.2 With a Usable 1M Token Context, Two Thinking Effort Levels, and No Benchmarks at Launch
Z.ai launches GLM-5.2 with a usable 1M-token context window, two thinking-effort levels (High and Max), and same-day availability across all Coding Plan tiers. The 5x jump from GLM-5.1's 200K window lets coding agents hold entire mid-sized repositories in working memory without constant summarization. Setup is a drop-in swap (base URL + model ID) for Claude Code, Cline, and OpenClaw. Critical caveat: Z.ai published zero benchmarks at launch — no SWE-bench, Terminal-Bench, or Code Arena scores. The 744B MoE backbone (40B active params) is unchanged from GLM-5 lineage; all gains are post-training and context engineering.
-
LLM Agents Can See Code Repositories
Justy and Cody dig into SeeRepo, a paper asking whether coding agents should literally see repository structure instead of flattening everything into text. The result is narrower and more useful than the headline: vision alone is worse, but a hybrid setup that adds rendered dependency graphs during fault localization cuts token use and often keeps accuracy flat or slightly better.
-
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.
-
End to End Context Compression at Scale
Justy and Cody dig into Latent Context Language Models (LCLMs) — encoder-decoder compressors that shrink long prompts into short latent sequences, cutting memory and latency at ratios up to 1:16 while staying competitive on accuracy. They cover the architecture search, the training recipe, the agent use-case, and what production deployment actually looks like.
-
EvoArena: Tracking Memory Evolution for Robust LLM Agents in Dynamic Environments
Justy and Cody dig into EvoArena, a benchmark for testing whether LLM agents can survive changing environments instead of one frozen snapshot. They unpack EvoMem, the paper’s git-like patch memory that stores what changed, why it changed, and the evidence behind it, then argue about whether the gains are modest or more meaningful than they look for production systems.
-
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.
-
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.
-
A New Study from Harvard and Perplexity Finds AI Agents Perform 26 Minutes of Autonomous Work per Session vs 33 Seconds for Search
Justy and Cody unpack a Harvard‑Perplexity study showing AI agents can do tens of minutes of autonomous work per session versus seconds for plain search, discussing the cost‑structure model, real‑world impact, and limits of the findings.
-
LatentSkill: From In Context Textual Skills to In Weight Latent Skills for LLM Agents
Exploring LatentSkill, a framework that turns textual agent skills into weight-space LoRA adapters, cutting prompt overhead while keeping modularity and composability. Cody digs into the hypernetwork design and trade-offs; Justy asks what shipping this looks like and who’d actually adopt it.
-
When Tools Fail: Benchmarking Dynamic Replanning and Anomaly Recovery in LLM Agents
Justy and Cody dive into ToolMaze, a new benchmark exposing how LLM agents crumble when tools fail silently or loudly. They discuss the gap between happy-path demos and real-world chaos, focusing on implicit semantic errors that trip up even large models, and debate whether dynamic replanning is a solvable engineering problem or a fundamental scaling bottleneck.
-
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.
-
Rethinking Continual Experience Internalization for Self Evolving LLM Agents
Jingwen Chen et al. diagnose why iterative experience internalization fails in LLMs and prescribe a three-part fix—principle-level granularity, step-wise injection, off-policy context-distillation—that turns capability collapse into compounding improvement.
-
Where Do Deep Research Agents Go Wrong? Span Level Error Localization in Agent Trajectories
Deep-research agents like Claude and GPT solve long, multi-step tasks by searching, using tools, and synthesizing evidence. The problem: when they fail, you only know the final answer is wrong — not WHERE in the trajectory the mistake actually happened. This paper introduces TELBench, a 1,000-instance benchmark for pinpointing harmful errors in agent trajectories at the span level, and DRIFT, a claim-centric auditing framework that tracks what claims the agent makes, checks if they're supported by evidence, and traces which unsupported claims later break the answer. The approach improves error localization accuracy by up to 30 points over naive LLM prompting.
-
NVIDIA Nemotron 3 Ultra Powers Faster, More Efficient Reasoning for Long Running Agents | NVIDIA Technical Blog
NVIDIA’s Nemotron 3 Ultra (550B parameters, 55B active) targets long-running agent workflows with hybrid Mamba-Transformer layers, NVFP4 quantization, LatentMoE routing, and multi-token prediction. It claims 5x throughput and up to 30% cost savings on agent tasks via token efficiency, while posting leading scores on Agent Productivity PinchBench (91%), Long Context Ruler @1M (95%), and others. Open weights, open recipes, and a transparent RL data pipeline aim at broad fine-tuning and domain specialization.
-
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.
-
MiniMax M3 debuts, eclipsing GPT 5.5 and Gemini 3.1 Pro on key benchmark performance for just 5 10% of the cost
Justy and Cody react to MiniMax-M3’s launch: frontier-tier coding and agentic performance with a 1M-token context window at 5–10% the cost of GPT-5.5 and Gemini 3.1 Pro, with open weights coming in 10 days. Cody digs into the MiniMax Sparse Attention (MSA) architecture that cuts quadratic attention costs, while Justy debates who this actually changes things for in practice.
-
MemTrain: Self Supervised Context Memory Training
Self-supervised framework MemTrain improves LLM context memory by training on unlabeled Wikipedia with coupled proxy tasks—masked reconstruction and memory recall—using GRPO. Achieves up to 17.67-point gains on long-horizon reasoning without task-specific labels.
-
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.
-
Tinyfish Launches Bigset an Open Source Multi Agent System That Builds Structured Live Datasets From Plain English Descriptions
Justy and Cody dig into BigSet, TinyFish's open-source system for turning plain-English data requests into live structured datasets. Cody likes the architecture more than the marketing, but questions how far 'just describe the data' really goes once recall, freshness, and schema ambiguity matter. Justy argues the real value is not magic scraping, it's collapsing a painful workflow for teams that need decent live tables fast. They land on BigSet as a credible workflow product with real technical thought behind it, but not a universal dataset machine.
-
Microsoft launches MXC, an OS level sandbox for AI agents, with OpenAI and Nvidia already on board
Microsoft introduces MXC, an OS-level sandbox for AI agents, aiming to address security concerns and provide a controlled environment for autonomous AI software.
-
Task Focused Memorization for Multimodal Agents
Justy and Cody dig into TaskMem, a paper on teaching multimodal agents what to remember from endless streams of video. They unpack the core idea of turning memory creation into a learnable policy, why that matters for embodied agents and long-horizon systems, and how the two-phase reinforcement learning setup tries to balance faithful recall with task usefulness.
-
SkillAdaptor: Self Adapting Skills for LLM Agents from Trajectories
Justy and Cody discuss SkillAdaptor, a new training-free framework that pinpoints the exact step where an LLM agent fails, rather than blaming the whole session. They debate whether this 'step-level' precision makes it shippable for production agents today or just a clever research trick.
-
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.
-
How query logs fix AI agent SQL errors
Justy and Cody dig into DataHub's new Context Intelligence layer, which mines SQL query logs to build a semantic index for AI agents. They unpack why raw schema fails at scale, whether query history actually solves the hallucination problem, and who should care about this in practice.
-
Exploring Autonomous Agentic Data Engineering for Model Specialization
Exploring Next episode 440: Cody and Justy dig into a new paper on autonomous agentic data engineering, where LLMs act as self-driving data engineers to curate domain-specific training sets—no humans in the loop. They unpack how GPT-5.2 built an iterative curriculum that boosted a student model by 57% and debate whether this is a research toy or a shippable path to domain adaptation. The code’s on GitHub at DataAgent.
-
LongTraceRL: Learning Long Context Reasoning from Search Agent Trajectories with Rubric Rewards
Justy and Cody unpack LongTraceRL, a paper that trains long-context reasoning models using realistic search-agent distractors and entity-level rubric rewards, with a short look at what would make it shippable.
-
The Infrastructure Behind Making Local LLM Agents Actually Useful | Towards Data Science
A conversation about making local LLM agents actually usable, focusing on the infrastructure challenges of running scientific agents with open-weight models. The hosts discuss the author's experience building a single-cell RNA-seq analysis agent, the problem of fixed prefix costs in long tool-use loops, vLLM optimizations for inference speed, and context management for long-running sessions.
-
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.
-
GitHub Tencent/TencentDB Agent Memory: TencentDB Agent Memory delivers fully local long term memory for AI Agents via a 4 tier progressive pipeline, with zero external API dependencies.
Justy and Cody dissect Tencent's new 'Agent Memory' repo, which claims to solve AI context bloat by using symbolic short-term memory and layered long-term storage instead of flat vector dumps. Cody leads with skepticism about the 'symbolic' Mermaid diagram approach and the specific benchmark claims against OpenClaw, while Justy argues the product value lies in stopping agents from forgetting SOPs. They debate whether hierarchical memory is the missing link for long-horizon tasks or just another complex caching strategy, landing on a cautious 'promising for enterprise, overkill for hobbyists' verdict.
-
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.
-
Replacing RAG with bash cut AI retrieval costs 30%
Justy and Cody dig into the argument behind direct corpus interaction, where agents use terminal tools like grep and find instead of relying only on vector search. They like the core point that retrieval interfaces can bottleneck reasoning, but they keep it grounded: this looks strongest for exact-evidence tasks in changing workspaces, and weakest as a blanket replacement for broad recall across huge corpora.
-
Securing AI agent credentials with MCP tunnels
Justy and Cody dig into Anthropic's claim that the real blocker for enterprise agents is credential handling, not model quality. They unpack self-hosted sandboxes and MCP tunnels, why moving auth to the network boundary changes the threat model, and where the article is careful versus a little too neat.
-
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.
-
RecursiveMAS cuts multi agent AI costs by 75%: researchers
Justy and Cody dig into RecursiveMAS, a research framework that lets multi-agent systems pass latent embeddings instead of text, cutting token usage and speeding up inference while keeping base model weights frozen.
-
5 Small Language Models for Agentic Tool Calling KDnuggets
Small language models are gaining ground on a critical frontier benchmark: tool calling. This episode looks at five compact, open-weight models that can route to APIs, format JSON arguments, and run multi-step agentic workflows without requiring a data center. Cody and Justy debate whether the gap between small and frontier models is closing fast enough to matter for real shipping teams.
-
Context architecture is replacing RAG in AI
Justy and Cody dissect the claim that context architecture is supplanting RAG for enterprise AI agents, weighing Redis Iris as a concrete example and debating its practical relevance for product teams.
-
Agent Evals
Justy and Cody dig into Cameron Wolfe’s argument that agent evals need to move from static benchmark thinking to realistic harnesses that test autonomy, tool use, recovery, and long-horizon behavior. They get specific about the agentic loop, why tool-call correctness is only part of the story, and where outcome-based evals can hide ugly behavior. Cody mostly buys the technical framing, with caveats about overfitting to harnesses and the difficulty of defining ground truth trajectories. Justy keeps pulling it back to who actually needs this now: teams shipping coding, workflow, or other higher-stakes agents where a demo is not the same as reliability.
-
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.
-
MetaAgent X : Breaking the Ceiling of Automatic Multi Agent Systems via End to End Reinforcement Learning
Justy and Cody discuss MetaAgent-X, a new paper proposing end-to-end reinforcement learning for multi-agent systems. They break down how it solves the 'frozen-executor ceiling' by jointly optimizing both the agent that designs the workflow and the agents that execute it. Cody explains the hierarchical rollout mechanism and stagewise co-evolution, while Justy explores what this means for production pipelines that currently rely on static prompts. They touch on the 21.7% performance gains, the reality of training stability, and whether this moves us from 'prompt engineering' to actual 'system engineering.'
-
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.
-
Hermes Unlocks Self Improving AI Agents, Powered by NVIDIA RTX PCs and DGX Spark
Hermes is a rapidly growing, self-improving AI agent framework that runs locally on NVIDIA RTX PCs and DGX Spark, using small but powerful Qwen models to do what previously required data-center scale.
-
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.
-
Implementing Prompt Compression to Reduce Agentic Loop Costs MachineLearningMastery
Justy and Cody kick around whether prompt compression is actually a smart production habit or just another neat demo. Cody starts skeptical about summary drift and hidden complexity, then they get concrete on why long agent loops get expensive fast, what the article's Python example is really proving, and where compressed history plus distilled instructions make sense right now.
-
SocialReasoning Bench shows the limits of today’s AI agents
Justy and Cody dig into SocialReasoning-Bench, a new benchmark for whether AI agents actually advocate for a user instead of just finishing the task. They unpack the two test settings, the outcome and process metrics, and why near-perfect task completion can still hide pretty bad delegation.
-
Speeding up agentic workflows with WebSockets in the Responses API
Justy and Cody dig into OpenAI’s writeup on speeding up agentic workflows with WebSockets in the Responses API. Cody is skeptical of the hype around raw model speed, while Justy keeps pulling it back to user pain: long, repetitive agent loops that make coding tools feel sluggish. They land on a practical read — the transport change matters most when the model is fast enough that API overhead becomes the bottleneck — and they sketch a weekend experiment for building a tiny stateful agent loop.
-
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.
-
ARIS: Autonomous Research via Adversarial Multi Agent Collaboration
Justy and Cody dig into ARIS, an open-source harness for autonomous ML research that assumes a single long-running agent will eventually make unsupported claims. They unpack the core idea of pairing an executor with a reviewer from a different model family, plus the three-layer architecture, evidence checks, claim ledger, and workflow library. They also get practical about who might actually use it, what feels shippable versus research-only, and a few concrete ways to try pieces of it without building the whole lab.
-
Validating agentic behavior when “correct” isn’t deterministic
GitHub's new validation framework for agentic systems moves beyond brittle, step-by-step testing toward outcome-focused validation. When autonomous agents (like Copilot Coding Agent) interact with real environments, correctness is no longer deterministic—loading screens may appear or vanish, timing shifts, and multiple valid action sequences can succeed. The framework uses dominator analysis and graph-based modeling (Prefix Tree Acceptors) to distinguish between essential outcomes and incidental noise, requiring only 2–10 successful traces to build a ground-truth model. Cody finds the approach clever but questions whether it scales beyond UI automation; Justy sees real market traction in CI/CD reliability and enterprise adoption.
-
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.
-
Benchmarking Multi Agent LLM Architectures for Financial Document Processing: A Comparative Study of Orchestration Patterns, Cost Accuracy Tradeoffs and Production Scaling Strategies
Justy and Cody break down a benchmark of four multi-agent LLM orchestration patterns for extracting structured data from SEC filings, focusing on cost, accuracy, latency, and what’s actually shippable in production. They compare sequential, parallel, hierarchical, and reflexive setups across 10,000 filings and land on a practical middle ground: hierarchical orchestration gets close to the best accuracy without the reflexive loop’s big cost hit.
-
Anthropic will let its managed agents dream
Justy and Cody talk through Anthropic’s idea of managed agents that can “dream” or rehearse outcomes before acting, with attention to product trust, architecture, sandboxes, and a small weekend build.
-
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.
-
HeavySkill: Heavy Thinking as the Inner Skill in Agentic Harness
Justy and Cody dig into HeavySkill, a paper arguing that a lot of so-called agent harness magic is really a simpler inner pattern: generate multiple reasoning paths in parallel, then run a separate deliberation pass that compares and summarizes them. They unpack the memory-cache trick, why it can beat plain Best-of-N, where the gains seem to come from, and what this means for builders deciding between brittle orchestration and something more shippable.
-
The RAG era is ending for agentic AI — a new compilation Stage knowledge layer is what comes next
Pinecone just announced Nexus, a 'knowledge engine' that shifts reasoning from inference time to a compilation stage — meaning agents get pre-built, task-specific knowledge artifacts instead of rediscovering context from scratch every session. Justy and Cody dig into why RAG was never really built for agents, what the architecture actually does, and whether the 98% token reduction claim holds water.
-
From Context to Skills: Can Language Models Learn from Context Skillfully?
Cody and Justy dig into Ctx2Skill, a self-evolving framework that turns long, dense context into reusable natural-language skills for language models. They talk through the core loop, the role of Challenger, Reasoner, Judge, and the replay trick that keeps the system from drifting into weird overfit territory, then land on what it means for product teams trying to ship context-heavy workflows.
-
Meta Introduces Autodata an Agentic Framework That Turns AI Models Into Autonomous Data Scientists for High Quality Training Data Creation
Justy and Cody dig into Meta’s Autodata and why better data, not just bigger models, is the pain point showing up everywhere right now. They unpack Agentic Self-Instruct, the four-agent setup, the weak-versus-strong solver idea, and why turning extra inference compute into better training data is a pretty interesting trade. They also get practical about who would adopt it, where the friction is, and a couple of concrete weekend experiments to try.
-
The scaffolding era is over. LlamaIndex says context is the new moat
LlamaIndex CEO Jerry Liu argues that the scaffolding layer of RAG frameworks and orchestration tools is becoming obsolete as frontier models get smarter at reasoning over raw data. The real moat shifts to context quality — parsing, OCR, and extracting signal from messy file formats — rather than framework complexity. Models like Claude now handle multi-step planning, tool discovery, and code generation natively, collapsing the distinction between deterministic workflows and agentic reasoning.
-
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.
-
FAMA: Failure Aware Meta Agentic Framework for Open Source LLMs in Interactive Tool Use Environments
Justy and Cody dig into FAMA, a failure-aware orchestration framework for smaller open-source tool-using LLM agents. They unpack why long multi-turn support-style tasks keep breaking, how FAMA studies failed trajectories and then routes only the right helper agents into context, and why that matters for teams trying to ship cheaper, more reliable agents without fine-tuning or massive reinforcement-learning pipelines.
-
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.
-
Alibaba's HDPO cuts AI agent tool overuse from 98% to 2%
Justy and Cody dig into Alibaba's HDPO and Metis, a training setup that teaches AI agents to stop calling tools by default. Cody likes the core idea because it separates accuracy from efficiency during reinforcement learning, but he questions how portable the benchmark win is. Justy pushes on why this matters for real products right now: users feel latency, teams feel API bills, and nobody wants an agent that opens a toolbox for a task it already knows how to do.
-
Agentic AI: How to Save on Tokens | Towards Data Science
Cody and Justy examine whether the token-saving techniques in Ida Silfverskiöld's article (prompt caching, semantic caching, lazy-loading, routing, context cleanup) are practical wins or theoretical cost-cutting that introduces real friction. Cody opens skeptical: the savings are real but the tradeoffs are often hidden or underestimated. Justy counters that for production teams already bleeding money on agentic AI, even 20-30% savings justifies the engineering lift. They land on a nuanced take: prompt caching is genuinely low-risk and worth it; semantic caching and aggressive routing are trickier and need honest trade-off audits before deployment.
-
DV World: Benchmarking Data Visualization Agents in Real World Scenarios
Justy and Cody dig into DV-World, a new benchmark from a multi-institution research team that stress-tests AI data visualization agents on real-world tasks — spreadsheet manipulation, cross-framework chart evolution, and handling ambiguous user intent. Even the best models top out around 50%, which tells you a lot about where the gap actually is.
-
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.
-
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.
-
Cut AI token usage by 96%? Here's how AWS Strands Agents does it.
AWS Strands Agents is a way to cut agent token usage by making models ask for only the context they need, when they need it. Instead of stuffing huge prompts up front, it uses tools, memory, and session state to keep agents lean, which matters for cost, latency, and scaling.
-
Recursive Multi Agent Systems
RecursiveMAS is a new multi-agent framework from researchers at UIUC, Stanford, NVIDIA, and MIT that replaces text-based agent handoffs with latent-space recursion — cutting token usage by up to 75%, speeding up inference 2.4x, and improving accuracy by 8.3% across nine benchmarks. Justy and Cody dig into why passing hidden states instead of words is such a big deal, what the RecursiveLink module actually does, and whether any of this is shippable today.
-
Definity embeds agents inside Spark pipelines to catch failures before they reach agentic AI systems
Episode 344 of Exploring Next takes a skeptical look at Definity putting agents inside Spark and dbt execution so teams can catch stale inputs, skew, memory pressure, and bad downstream writes during a run instead of after the damage is done. Cody likes the placement but questions how much autonomy teams will really allow in production. Justy argues the buyer story is strong for data teams supporting AI systems and expensive on-prem workloads where wasted runs hurt immediately.
-
ClawMark: A Living World Benchmark for Multi Turn, Multi Day, Multimodal Coworker Agents
ClawMark is a benchmark for evaluating AI agents as persistent coworkers across multi-day workflows with dynamic, stateful environments. Unlike existing benchmarks that run single-episode tasks in static environments, ClawMark spans multiple in-universe workdays with exogenous state changes (emails arrive, calendars shift, files update) between turns, multimodal evidence (PDFs, audio, video, spreadsheets), and deterministic rule-based scoring via 1,537 Python checkers. The benchmark contains 100 tasks across 13 professional scenarios running against five sandboxed services (filesystem, email, calendar, knowledge base, spreadsheet). Current frontier models reach 75.8 weighted score but only 20% strict task success, revealing that adaptation to changing state remains a core unsolved challenge.
-
American AI startup Poolside launches free, high performing open model Laguna XS.2 for local agentic coding
Justy and Cody unpack Poolside’s new Laguna XS.2, an Apache 2.0 open model aimed at local agentic coding, plus the bigger Laguna M.1, the pool agent harness, and the shimmer coding environment.
-
Rewarding the Scientific Process: Process Level Reward Modeling for Agentic Data Analysis
DataPRM is a process reward model built specifically for agentic data analysis that fixes two critical gaps in general-purpose PRMs: silent errors (code runs but produces wrong results) and grounding errors (penalizing necessary exploration). It works by actively probing the environment to validate intermediate states and using a ternary reward strategy to distinguish between correctable mistakes and irrecoverable failures. The team built a 7K-instance training dataset and show 7-11% improvements on benchmarks with only 4B parameters.
-
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.
-
Open source Xiaomi MiMo V2.5 and V2.5 Pro are among the most efficient (and affordable) at agentic 'claw' tasks
Xiaomi's open-source MiMo-V2.5 and V2.5-Pro models claim top-tier efficiency for agentic 'claw' tasks—autonomous agents that handle email, content creation, and complex coding work. The Pro version uses 40-60% fewer tokens than GPT-5.4 or Claude Opus while costing a fraction as much. Cody questions whether token efficiency alone translates to real production wins, while Justy sees a genuine market opening for cost-conscious enterprises building agent workflows.
-
Build a Reinforcement Learning Powered Agent That Learns to Retrieve Relevant Long Term Memories
Cody and Justy dig into a tutorial that trains an RL agent — using PPO via Stable-Baselines3 — to retrieve long-term memories more accurately than plain cosine similarity search. They debate whether the added complexity is justified, who actually needs this, and what it would take to move from a synthetic demo to something production-worthy.
-
RAG precision tuning can quietly cut retrieval accuracy by 40%, putting agentic pipelines at risk
Justy and Cody dig into new Redis research showing that fine-tuning RAG embeddings for sentence-level precision can quietly hurt general retrieval, sometimes by a lot. They unpack why that matters more in agent pipelines, where one bad retrieval can snowball into bad downstream actions, and why common fixes like hybrid search, MaxSim reranking, or bigger models don't really solve the structural problem. The episode lands on a practical takeaway: keep recall fast, add a separate verification step when correctness actually matters.
-
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.
-
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.
-
Towards a science of scaling agent systems: When and why agent systems work
A skeptic’s take on Google Research’s paper on scaling agent systems. Cody argues the useful part is not “more agents” but the evidence that coordination only helps when the task structure fits. Justy pushes on why that matters for teams shipping assistants right now, where cost, reliability, and user trust beat demo flair. Together they unpack the five architectures, the strong gains on parallel work, the collapse on sequential planning, and what a solo builder could test this weekend.
-
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.
-
ClawEnvKit: Automatic Environment Generation for Claw Like Agents
Cody and Justy dig into ClawEnvKit, a pipeline from researchers at UMD, UC Berkeley, UCLA, and MBZUAI that automates the creation of training and evaluation environments for claw-like LLM agents — cutting construction cost by 13,800x compared to human curation.
-
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.
-
Kimi K2.6 runs agents for days — and exposes the limits of enterprise orchestration
Exploring Next, episode 311. We look at Kimi K2.6 and why agents that run for hours or days are exposing a weak spot in enterprise orchestration, governance, and state management.
-
Kimi K26 Is the Open Model Release
Justy and Cody dig into why Kimi K2.6 lands at exactly the right moment for people trying to run long-lived coding agents: it’s open, strong on coding, and can actually see screenshots and video without bolting on a separate vision model. They unpack the 1T MoE design with 32B active parameters, the 262K context window, benchmark wins that matter, and Moonshot’s bigger bet on tool-heavy, long-horizon agent work. They also separate the impressive parts from the marketing gloss, then close with concrete stuff to try this week.
-
Moonshot AI Releases Kimi K2.6, Beats Top US Models On Some Benchmarks
Justy and Cody dig into why Kimi K2.6 matters right now: not because of a flashy leaderboard screenshot, but because it appears unusually strong at the stuff teams actually pay for — coding work, tool use, and long-running task execution. They unpack the benchmark wins, the 12-to-13-hour autonomous coding demos, the scaled-up agent swarm design, and what Moonshot seems to be optimizing for. They end with concrete things to try if you want to test this class of model yourself.
-
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.
-
OpenClaw vs. Hermes Agent: The race to build AI assistants that never forget
Justy and Cody dig into persistent AI agents by comparing OpenClaw and Hermes Agent, focusing on why memory matters for real users, how each system stores and retrieves context, and where the engineering trade-offs show up in production.
-
LongAct: Harnessing Intrinsic Activation Patterns for Long Context Reinforcement Learning
Justy and Cody dig into LongAct, a paper about making long-context RL work better by updating only the attention weights tied to unusually large query and key activations. They unpack why that matters for long docs, agents, and multi-step reasoning, how the saliency-guided sparse updates map activation outliers back to specific weight rows, and why the reported gains across LongBench v2, RULER, and multiple RL algorithms suggest this could be more than a lab curiosity.
-
Cloudflare Launches Code Mode MCP Server to Optimize Token Usage for AI Agents
Cloudflare's new Model Context Protocol (MCP) server powered by Code Mode reduces token usage for AI agents, making it possible to interact with complex APIs more efficiently.
-
Pi Monorepo
Exploring the Pi Monorepo and its tools for building AI agents and managing LLM deployments.
-
AI's next bottleneck isn't the models — it's whether agents can think together
AI's next bottleneck is not the models, but whether agents can think together, requiring next-level infrastructure and shared cognition
-
Context Engine MCP | Augment Code
Exploring the Context Engine MCP and its potential to revolutionize coding agents
-
Vending Machine Run by Claude More of a Disaster Than Previously Known
Episode 290 of Exploring Next dives into the story of Claude, an AI model tasked with running a vending machine, and the chaos that ensued.
-
Vending Bench: A Benchmark for Long Term Coherence of Autonomous Agents
Exploring the Vending-Bench research paper and its implications for long-term coherence in autonomous agents
-
Andon Labs
Exploring Andon Labs and their work on autonomous organizations without human intervention
-
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.
-
Databricks tested a stronger model against its multi step agent on hybrid queries. The stronger model still lost by 21%.
Databricks' research shows multi-step agents outperform single-turn RAG systems on hybrid queries, achieving gains of 20% or more on Stanford's STaRK benchmark suite.
-
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.
-
Deep Agents Deploy: an open alternative to Claude Managed Agents
Exploring Next Episode 282: Deep Agents Deploy, an open alternative to Claude Managed Agents
-
We're bringing the advisor strategy to the Claude Platform. Pair Opus as an advisor with Sonnet or Haiku as an execu...
Claude AI's advisor strategy and its implications on AI development
-
Alright agent nerds, if you care about your tokens and usage limits, pay attention to the tools you give to your agen...
Episode 280 of Exploring Next dives into the importance of choosing the right browser tools for agents, exploring their impact on token usage and latency.
-
New framework lets AI agents rewrite their own skills without retraining the underlying model
Episode 277 of Exploring Next covers Memento-Skills, a framework that enables AI agents to rewrite their own skills without retraining the underlying model, and its implications on autonomous agents and enterprise teams.
-
AI joins the 8 hour work day as GLM ships 5.1 open source LLM, beating Opus 4.6 and GPT 5.4 on SWE Bench Pro
Discussion of GLM-5.1, a new open-source large language model that can work autonomously for up to eight hours on a single task, and its implications on the AI industry
-
ClawArena: Benchmarking AI Agents in Evolving Information Environments
Exploring ClawArena, a benchmark for evaluating AI agents in evolving information environments
-
Rightnow AI Releases Autokernel an Open Source Framework That Applies an Autonomous Agent Loop to GPU Kernel Optimization for Arbitrary Pytorch Models
Exploring the release of Autokernel, an open-source framework for autonomous GPU kernel optimization in PyTorch models
-
LLM Wiki
Exploring the LLM Wiki concept and its potential applications
-
Continual learning for AI agents
Continual learning for AI agents enables systems to improve over time by updating model weights, harnesses, and context. This episode explores the three distinct layers of agentic systems and how they can be applied in real-world scenarios.
-
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.
-
Why pgEdge thinks MCP (not an API) is the right way for AI agents to talk to databases
Episode 268 of Exploring Next discusses pgEdge's approach to AI agents talking to databases using MCP, a non-API solution. Izzo and Boone dive into the substance of MCP, explaining its key mechanisms, design choices, and architecture. They connect it to real-world problems and current trends, exploring the product angle and tech behind it.
-
LangChain Academy New Course: Monitoring Production Agents
Episode 265 dives into LangChain Academy's new course on monitoring production agents. Izzo and Boone explore why agent observability has become critical as more companies deploy AI agents to production, examining the specific monitoring techniques, observability patterns, and debugging approaches covered in the course.
-
Imagine if your Teams or Slack messages automatically turned into secure context for your AI agents — PromptQL built it
PromptQL turns Slack/Teams conversations into secure, persistent memory for AI agents. Instead of coordination theater, every discussion becomes actionable context that agents can use to actually execute work—fixing bugs, updating CRMs, pulling cross-platform data—while maintaining enterprise security controls.
-
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.
-
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.
-
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.
-
SlopCodeBench: Benchmarking How Coding Agents Degrade Over Long Horizon Iterative Tasks
Gabriel Orlanski and team at UW-Madison just dropped SlopCodeBench — the first benchmark that measures what happens when coding agents have to keep extending their own messy code. Turns out every single model fails spectacularly at long-term software development, with code quality degrading so badly that extensions become impossible. This isn't about whether agents can solve coding problems — it's about whether they can build software that doesn't collapse under its own weight.
-
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.
-
The three disciplines separating AI agent demos from real World deployment
Episode 249 explores why AI agents consistently fail in real-world enterprise deployments despite impressive demos, examining Creatio's three-discipline methodology for production-ready autonomous agents that can handle 80-90% of tasks independently through data virtualization, agent dashboards with KPIs, and tightly bounded use-case loops.
-
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.
-
Ai2 releases MolmoWeb, an open weight visual web agent with 30K human task trajectories and a full training stack
Ai2 releases MolmoWeb, the first open-weight visual web agent that ships with its full training data and pipeline. Unlike closed APIs or empty frameworks, MolmoWeb includes 30K human task trajectories, works purely from screenshots, and gives developers full visibility into how it was built.
-
How xMemory cuts token costs and context bloat in AI agents
Featured How xMemory cuts token costs and context bloat in AI agents Ben Dickson March 25, 2026 Image credit: VentureBeat with ChatGPT Standard RAG pipelines break when enterprises try to use them for long-term, multi-session LLM agent deployments. This is a critical limitation as demand for persistent AI assistants grows.
-
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.
-
Andrej Karpathy's new open source 'autoresearch' lets you run hundreds of AI experiments a night — with revolutionary implications
Andrej Karpathy released autoresearch, a 630-line open source script that runs autonomous AI experiments overnight. The system creates an optimization loop where agents modify their own code, test hypotheses, and keep improvements—completing hundreds of experiments while humans sleep. Early adopters distributed the approach across networks and applied it beyond ML to marketing, suggesting a fundamental shift toward automated scientific discovery.
-
Autoresearch
Karpathy's autoresearch lets AI agents autonomously experiment on machine learning models overnight — modifying code, training for 5 minutes, evaluating results, and iterating while you sleep. We dive into how it works, the clever design constraints, and why this might be the beginning of fully autonomous AI research.
-
Hyperagents
Episode 237 explores Hyperagents, a breakthrough in self-improving AI that goes beyond just getting better at tasks to actually improving how it improves. Izzo examines the product potential while Boone breaks down the technical architecture that enables genuine metacognitive self-modification.
-
Xiaomi stuns with new MiMo V2 Pro LLM nearing GPT 5.2, Opus 4.6 performance at a fraction of the cost
Xiaomi's MiMo-V2-Pro LLM achieves near GPT-5.2 performance at 1/7th the cost through sparse architecture with only 42B active parameters out of 1T total, targeting autonomous agents over conversational AI
-
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.
-
AgentProcessBench: Diagnosing Step Level Process Quality in Tool Using Agents
Episode 234 explores AgentProcessBench, a new benchmark for evaluating AI agents' step-by-step decision-making in realistic tool-use scenarios. Unlike math problems where you can backtrack from wrong answers, agent mistakes in the real world often have irreversible consequences - making it critical to catch errors before they cascade. The hosts dig into the technical innovation of ternary labeling (correct/neutral/error) and error propagation rules, while discussing who would actually build products using these insights and what the path to production looks like.
-
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.
-
Evaluating AI Agents in Practice: Benchmarks, Frameworks, and Lessons Learned
Deep dive into practical AI agent evaluation frameworks, moving beyond traditional NLP metrics to assess real-world behavior, reliability, and production readiness. Covers hybrid evaluation approaches, operational constraints, and specific tools like MLflow, TruLens, and LangChain Evals.
-
z.ai debuts faster, cheaper GLM 5 Turbo model for agents and 'claws' — but it's not open Source
Z.ai launches GLM-5-Turbo, a proprietary variant of their open-source GLM-5 model optimized for agent workflows and tool use. At $4.16 per million tokens total cost, it undercuts competitors while delivering better tool reliability and execution stability for multi-step automation tasks.
-
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%.
-
The “files are all you need” debate misses what's actually happening in agent memory architecture
Exploring Next episode 227 dives deep into AI agent memory architecture, explaining why the 'files are all you need' approach is missing the bigger picture. Izzo and Boone break down the key mechanisms behind persistent memory systems, compare different architectural approaches, and discuss why this matters for anyone building production AI agents.
-
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.
-
Agents need vector search more than RAG ever did
Why agents are driving a massive spike in vector search complexity, making purpose-built retrieval infrastructure more critical than ever. We dig into Qdrant's latest release, real production stories from companies handling millions of documents, and the three signals it's time to upgrade your vector setup.
-
Galileo releases Agent Control, a centralized guardrails platform for enterprise AI agents
Galileo launches Agent Control, an open-source centralized guardrails platform for enterprise AI agents, addressing the critical need for safety and control as AI agents become more autonomous in production environments.
-
In Context Reinforcement Learning for Tool Use in Large Language Models
Episode 219 explores In-Context Reinforcement Learning (ICRL), a breakthrough approach that teaches language models to use external tools without expensive supervised fine-tuning. Instead of requiring thousands of labeled examples upfront, ICRL uses few-shot prompting during reinforcement learning training, gradually reducing examples until the model masters tool use independently.
-
Google finds that AI agents learn to cooperate when trained against unpredictable opponents
Google's Paradigms of Intelligence team discovered that AI agents naturally develop cooperative behaviors when trained against diverse, unpredictable opponents rather than being programmed with hardcoded coordination rules. This breakthrough offers a scalable alternative to traditional multi-agent frameworks by using standard reinforcement learning techniques to produce adaptive social behaviors through in-context learning.
-
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.
-
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.
-
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.
-
Towards a Science of AI Agent Reliability
Title: arXiv Query: search_query=&id_list=2602.16666&start=0&max_results=10 Authors: Stephan Rabanser, Sayash Kapoor, Peter Kirgis, Kangheng Liu, Saiteja Utpala, Arvind Narayanan Abstract: AI agents are increasingly deployed to execute important tasks. While rising accuracy scores on standard benchmarks suggest rapid progress, many agents still continue to fail in practice.
-
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.
-
Multi Agent cooperation through in Context co Player inference
Exploring how sequence models can learn cooperation in multi-agent settings without hardcoded assumptions about other players, using in-context learning to naturally develop mutual cooperation strategies.
-
Managed MCP servers for Google Cloud databases | Google Cloud Blog
Google Cloud launches managed MCP servers for their database portfolio, letting AI agents directly interact with PostgreSQL, Spanner, Cloud SQL, Firestore, and Bigtable through the Model Context Protocol standard. No infrastructure to deploy — just configure endpoints and agents get secure, governed access to operational data.
-
New agent framework matches human engineered AI systems — and adds zero inference cost to deploy
Featured New agent framework matches human-engineered AI systems — and adds zero inference cost to deploy Ben Dickson February 18, 2026 Image credit: VentureBeat with ChatGPT Agents built on top of today's models often break with simple changes — a new library, a workflow modification — and require a human engineer to fix it. That's one of the most persistent challenges in deploying AI for the enterprise: creating agents that can adapt to dynamic environments without constant hand-holding.
-
Improving Deep Agents with harness engineering
LangChain improved their coding agent from Top 30 to Top 5 on Terminal Bench 2.0 by only changing the harness - the system that wraps around the model. They used trace analysis to identify failure patterns and implemented targeted fixes like self-verification loops, context injection, and reasoning budget optimization. The 13.7 point improvement shows how much performance gains come from better tooling around models, not just bigger models.
-
SurrealDB 3.0 wants to replace your five database RAG stack with one
SurrealDB 3.0 combines vector search, graph traversal, and relational queries into a single transactional database engine, aiming to replace the complex multi-database stacks commonly used in RAG systems. The Rust-native architecture stores agent memory as graph relationships directly in the database with full ACID guarantees across distributed nodes.
-
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.
-
NanoClaw solves one of OpenClaw's biggest security issues — and it's already powering the creator's biz
NanoClaw is a secure, lightweight alternative to OpenClaw that addresses critical security issues through OS-level container isolation. Created by Gavriel Cohen, it reduces OpenClaw's 400,000-line codebase to just 500 lines of TypeScript while providing sandboxed execution environments. The project emphasizes a 'Skills over Features' approach where AI customizes the codebase rather than shipping with pre-built integrations.
-
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.
-
Forge: Scalable Agent RL Framework and Algorithm
Izzo and Boone dive deep into MiniMax's Forge framework — a production-scale RL system that trained their M2.5 model across hundreds of thousands of real-world agent scaffolds. They explore how Forge solves the fundamental trilemma of system throughput, training stability, and agent flexibility through architectural innovations like middleware abstraction, windowed FIFO scheduling, and prefix tree merging for massive computational efficiency.
-
z.ai's open source GLM 5 achieves record low hallucination rate and leverages new RL 'slime' technique
z.ai's GLM-5 achieves record-low hallucination rates using a novel 'slime' reinforcement learning technique, scaling to 744B parameters while undercutting competitors by 6x on pricing. The model features native document generation and Agent Mode capabilities for enterprise workflows.
-
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.
-
MiniMax's new open M2.5 and M2.5 Lightning near state of the art while costing 1/20th of Claude Opus 4
MiniMax drops their M2.5 model that matches Claude Opus 4.6 performance at 1/20th the cost, using sparse MoE architecture and a novel RL training framework called Forge to create AI agents that can handle enterprise tasks autonomously.
-
MIT's new fine tuning method lets LLMs learn new skills without losing old ones
MIT researchers developed self-distillation fine-tuning (SDFT), a technique that lets large language models learn new skills without forgetting old ones. By using a model's own in-context learning abilities as both teacher and student, SDFT solves the catastrophic forgetting problem that forces companies to maintain separate models for each task.
-
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.
-
'Observational memory' cuts AI agent costs 10x and outscores RAG on long Context benchmarks
Observational memory is a new approach to AI agent memory that uses two background agents to compress conversation history into dated observation logs, achieving 10x cost savings through stable context windows that enable prompt caching while outperforming traditional RAG systems on long-context benchmarks.
-
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.
-
A RAG: Scaling Agentic Retrieval Augmented Generation via Hierarchical Retrieval Interfaces
A-RAG: Scaling Agentic Retrieval-Augmented Generation via Hierarchical Retrieval Interfaces Mingxuan Du 1 , Benfeng Xu 2† , Chiwei Zhu 1 , Shaohan Wang 1 , Pengyu Wang 1 Xiaorui Wang 2 , Zhendong Mao 1‡ 1 University of Science and Technology of China, Hefei, China 2 Metastone Technology, Beijing, China [email protected] Abstract Frontier language models have demonstrated strong reasoning and long-horizon tool-use capabilities. However, existing RAG systems fail to leverage these capabilities.
-
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.
-
Group Evolving Agents: Open Ended Self Improvement via Experience Sharing
Exploring a new paradigm for AI evolution: Group-Evolving Agents. Are they the future or just another research paper?
-
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.
-
Reinforcement World Model Learning for LLM based Agents
The research introduces Reinforcement World Model Learning (RWML), a self-supervised method that enhances the capacity of large language models (LLMs) to navigate dynamic environments by learning action-conditioned world models. This addresses the limitations of LLMs in anticipating consequences and adapting to environmental changes, offering significant improvements in performance without relying on expert data.
-
Self Hinting Language Models Enhance Reinforcement Learning
The paper explores how self-hinting language models can enhance reinforcement learning, particularly in overcoming the challenges faced when rewards are sparse. By introducing hints generated by the model itself during training, it reshapes the distribution of outcomes, allowing for better learning signals and improved performance on difficult prompts. This approach not only addresses existing limitations but also offers a novel way to adaptively guide the training process.
-
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.
-
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.
-
Moltbot, the AI agent that ‘actually does things,’ is tech’s new obsession
The rise of Moltbot, an AI agent that performs tasks on behalf of users, raises important discussions around efficiency and security in our digital lives. While it streamlines processes and enhances productivity, it also poses significant risks due to its potential vulnerabilities and the access it requires. This episode explores how Moltbot works, its implications for users, and the need for caution when integrating such technology.
-
'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.
-
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.
-
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.
-
LLM in Sandbox Elicits General Agentic Intelligence
The LLM-in-Sandbox research presents a significant advancement in how large language models can autonomously explore and learn within a controlled environment. This enables them to tackle complex tasks across various domains without further training, enhancing their utility in real-world applications and offering new capabilities for developers and practitioners.
-
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.
-
Agentic Reasoning for Large Language Models
This dialogue explores the implications of agentic reasoning for large language models, discussing the potential for autonomous decision-making and its applications across various fields, while also addressing limitations and future directions.
AgentsResearch Paper -
Agentic R: Learning to Retrieve for Agentic Search
This dialogue explores the innovative approach of Agentic-R in enhancing agentic search through tailored retriever training, its implications for developers, and practical applications.
-
MAXS: Meta Adaptive Exploration with LLM Agents
MAXS introduces an innovative framework for improving the reasoning capabilities of LLM agents, addressing critical issues in multi-tool reasoning. The integration of lookahead strategies and trajectory convergence allows for more stable and efficient performance, making it highly relevant for developers and practitioners.
-
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.
-
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.
-
Adaptation of Agentic AI
The research on agentic AI adaptation presents a significant step toward creating more efficient and reliable AI systems. By establishing a structured framework for both agent and tool adaptations, it provides developers with essential guidance for improving AI capabilities, addressing challenges, and enhancing performance. This dialogue explores the implications of this research and its practical applications in the field.
-
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.
-
With 91% accuracy, open source Hindsight agentic memory provides 20/20 vision for AI agents stuck on failing RAG
The development of Hindsight agentic memory marks a pivotal advancement in AI, allowing agents to maintain context and provide insightful responses over time, unlike traditional RAG systems. This conversation explores how this technology works, its real-world implications, and why it matters to businesses and everyday users.
-
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.
-
Agent Engineering: A New Discipline
Agent engineering emerges as a vital discipline for developing reliable AI systems that adapt and learn from unpredictable interactions. As AI becomes integral to business processes, understanding how to manage the complexity and unpredictability of these agents is essential for organizations seeking to leverage their capabilities effectively.
-
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.
-
We Got Claude to Fine Tune an Open Source LLM
The recent development allowing Claude to fine-tune open-source language models marks a significant step in democratizing AI training. It simplifies the complex process of model training, making it accessible to more users and applications, ultimately driving innovation in various sectors.
-
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.
-
Exclusive: Agentic AI startup Prime Security raises $20M
The rise of agentic AI in software security is crucial as it addresses vulnerabilities during development, where traditional security measures often fall short. Prime Security's recent $20M funding aims to enhance these protective measures, showcasing a shift in how we safeguard software against breaches.
-
DeepSeek V3.2: Pushing the Frontier of Open Large Language Models
DeepSeek-V3.2 revolutionizes the efficiency of large language models with innovative techniques that enhance reasoning and performance in computational tasks, providing practical benefits across various domains.
-
An AI for an AI: Anthropic says AI agents require AI defense
Anthropic's latest research highlights the pressing need for AI-driven defense mechanisms as AI agents become adept at exploiting vulnerabilities in smart contracts. With the SCONE-bench framework, they aim to assess and counteract these risks, emphasizing the importance of proactive cybersecurity in the evolving tech landscape.
-
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.
-
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.
-
Multi Agent Systems Explained: How AI Agents & LLMs Work Together
In this episode, we discuss the impact of YouTube on the way we consume media and interact with content. We explore its role in democratizing content creation and the implications for creators and audiences alike.
-
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.
-
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.
-
Minimax M2 Is the New King of Open Source LLMs Especially for Agentic Tool
The Minimax M2 model emerges as a powerful open-source language model, enabling advancements in AI agents and tool usage, making AI more accessible and efficient for diverse 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.
-
Metas Dreamgym Framework Trains AI Agents in a Simulated World to Cut
Meta's DreamGym Framework is revolutionizing the way AI agents are trained by simulating complex environments, improving their efficiency and adaptability in real-world applications. This discussion explores how DreamGym works, its implications for various industries, and potential use cases that could redefine AI training.
-
Paper page Stabilizing Reinforcement Learning with LLMs: Formulation and Practices
This dialogue explores the advances in reinforcement learning (RL) through the integration of large language models (LLMs), specifically focusing on a recent study that provides new strategies for stabilizing RL training. The conversation highlights practical implications, potential use cases, and the future of RL in practical applications.
-
Paper page Agent Learning via Early Experience
This dialogue explores innovative strategies in agent learning through early experience, discussing their implications, practical applications, and limitations in real-world scenarios.
-
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.
-
Databricks Set to Accelerate Agentic AI by Up to 100x with Mooncake
Databricks' new 'Mooncake' technology aims to revolutionize agentic AI, making it faster and more efficient. This could drastically improve various sectors by enabling smarter, real-time data-driven decisions. Hosts delve into its implications, applications, and potential impact on industries.
-
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.
-
Meta AI Researchers Introduce Matrix a Ray Native a Decentralized Framework for Multi Agent Synthetic Data Generation
Editors Pick Agentic AI Tech News AI Paper Summary Technology AI Shorts Artificial Intelligence Applications Language Model Large Language Model Machine Learning New Releases Staff Meta AI Researchers Introduce Matrix: A Ray Native a Decentralized Framework for Multi Agent Synthetic Data Generation By Michal Sutter - November 30, 2025 How do you keep synthetic data fresh and diverse for modern AI models without turning a single orchestration pipeline into the bottleneck? Meta AI researchers introduce Matrix , a decentralized framework where both control and data flow are serialized into messages that move through distributed queues.
-
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.
-
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.
-
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.
-
Postgres for Agents | TigerData
In this episode, we explore the groundbreaking Agentic Postgres, the first database designed specifically for AI agents. Hosts Ajay and Mike discuss how the evolution from traditional development practices to agent-driven coding necessitates a new kind of database, highlighting key features like fast, zero-copy forks, native search capabilities, and more.
-
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.
-
Agentic Context Engineering Ace Self Improving LLMs via Evolving Contexts Not Fine Tuning
Tech News AI Paper Summary Technology Artificial Intelligence Editors Pick Machine Learning Staff Agentic Context Engineering (ACE): Self-Improving LLMs via Evolving Contexts, Not Fine-Tuning By Asif Razzaq - October 10, 2025 TL;DR : A team of researchers from Stanford University, SambaNova Systems and UC Berkeley introduce ACE framework that improves LLM performance by editing and growing the input context instead of updating model weights. Context is treated as a living “playbook” maintained by three roles— Generator, Reflector, Curator —with small delta items merged incrementally to avoid brevity bias and context collapse.
-
GLM 4.6: Advanced Agentic, Reasoning and Coding Capabilities
2025-09-30 · Research GLM-4.6: Advanced Agentic, Reasoning and Coding Capabilities Try it at Z.ai Call it at Z.ai HuggingFace 📄 Tech Report (GLM-4.5) Today, we are releasing the latest version of our flagship model: GLM-4.6 . Compared with GLM-4.5, this generation brings several key improvements: Longer context window: The context window has been expanded from 128K to 200K tokens, enabling the model to handle more complex agentic tasks.
-
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.
-
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.
-
xSVVTj9qiY
In this episode, we dive into the latest developments from the r/singularity community, focusing on AI advancements and the implications of human enhancement technologies. We discuss Google's SIMA 2, an innovative agent that interacts and learns in 3D environments, and what this means for our future.
-
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.
-
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.