Topic
State Management In Language Models
163 episodes
-
Vercel Open Sources durable harness for Crash Proof Coding Agents
Jessica and Cathy dig into Vercel's durable-harness, an open-source layer that makes coding agent sessions survive crashes by logging every turn, intent, and outcome into a durable workflow world. They focus on the real product gap it fills for cloud-hosted agents, the adapter strategy that wraps existing harnesses without rewriting them, and the trade-offs around state, storage, and portability.
-
Introducing Claude Duet
Vince and Ava dig into Claude Duet as a proactive agent app that tries to turn scattered work into a single ongoing thread. They focus on the real product claim, the safety machinery behind it, and the practical question of whether this is actually useful for people with too many moving parts.
-
Learning from Research: Toward Lifelong Agent Harness Evolution
Pippa and Tyler dig into ScholarEvolve, a framework that lets agents evolve their own harnesses by mining research papers for new mechanisms, not just reacting to failures. They unpack how it modularizes the harness, uses topic modeling over papers to propose concrete code changes, and runs a lifelong evolution loop on benchmarks like AppWorld and Tau2-Bench. They debate whether this is research-only or actually shippable, how it fits their running harness-as-product thesis, and what trade-offs and failure modes they’d worry about in production.
-
CTGT releases open source tool Concordance to trace why AI agents make inconsistent decisions
Jessica and Cathy unpack CTGT's Concordance, an Apache two-point-zero open source tool for tracing where AI agent workflows start making inconsistent decisions.
-
Deterministic Inference Did Not Make Our Pipeline Deterministic
CTGT's Concordance paper shows that enabling deterministic inference on a model didn't stop their pipeline from producing different compliance outputs across runs — because the non-determinism lived in the pipeline around the model, not in the model itself. Four runs of the same banking policy manual committed four different sets of obligations, including one run that dropped the rule requiring escalation to the Head of Compliance. The culprit: regenerating hex asset IDs on every upload silently changed 12,000-character prompts, and prompt sensitivity did the rest. Concordance, their Apache 2.0 tool, finds where runs diverge by comparing requests and responses alone.
-
From feral to fiduciary: making AI agents serve your interests
Justy and Cody examine the article’s argument for treating AI agents like fiduciaries: trust must be earned through continuous evidence, identity, policy enforcement, and runtime monitoring. They find the lifecycle approach useful, while questioning whether a single trust score can capture changing agent behavior or justify more autonomy.
-
Model Behavior: Week of October 19, 2026
We read this week as a shift away from trophy launches and toward who can make models useful in real deployments. We argue through NVIDIA, Beam, Mistral, Subquadratic, and why a quiet frontier week still moved the board.
-
From Microservices to Agents: the Next Evolution of Distributed Systems
Talon and Wildflower break down the core architectural shift from microservices to agentic AI, weighing what changes for teams building distributed systems and where the hype may be ahead of real product wins. They dig into how agentic systems move beyond deterministic service calls to runtime reasoning, the new pain points around context management and reliability, and where the next generation of AI infrastructure is likely to bite product teams.
-
LLM d 1.0 Advances Open, Cost Efficient AI Inference for Production Scale
Harper is skeptical that llm-d 1.0 changes the world just because it’s open and polished, while Laura argues the real story is production economics and the ugly Day 2 problems it finally addresses. They land on cautious approval: the claims are believable if you care about serving at scale, but the proof still mostly lives in controlled demos and partner-branded outcomes, not broad field evidence.
-
Scaling AI agents requires inventory, contracts and maintained context
Pippa and Tyler break down Felix Van de Maele's VentureBeat AI Week argument: enterprises hit a wall around 10-15 agents because governance, context, and cost scale exponentially. The fix isn't better models — it's inventory (knowing what agents exist), contracts (machine-readable runtime rules), and a maintained context layer (ontology) that survives platform swaps. Collibra's guardian agents enforce contracts deterministically, not with LLMs. The hosts connect this to their own coverage of the 'hallucination tax,' observability gaps, and the shift from execution to judgment as the real bottleneck.
-
Harness^2: Recursive Agent Harnessing for an Open World
Harness squared argues that open-world agents need to improve both the harness for the task in front of them and the process used to improve later harnesses. Its strongest idea is a contrastive edit loop that probes candidate changes without assuming a perfect task verifier, then stores reusable lessons rather than blindly carrying task-specific scaffolding forward.
-
Hark releases an AI personal assistant with a focus on privacy | TechCrunch
Hark Pro wants to make computer-using AI feel like a personal operating system rather than another chatbot. Pippa and Tyler examine its proactive interface, visible web navigation, privacy pitch, narrower computer-use model, and the difficult adoption question: will people trust an assistant with their whole digital lives?
-
Redesigning source control at Anthropic
Anthropic’s real argument isn’t 'we outgrew git' so much as 'AI changed the unit economics of software work, and human-scale developer infrastructure is now the choke point.' Vince likes the product read: if code generation is abundant, the winning layer becomes merge throughput, receipts, permissions, and review surfaces. Ava thinks the technical case mostly holds because Scion is a server-first system built for always-online agents, sparse checkouts, API-native repo queries, and lock-free incremental commits. They both land on the same take: this is another version of their boring-infrastructure thesis, just at absurd scale.
-
VentureBeat Agentic Orchestration Report
Justy and Cody dig into VentureBeat's orchestration survey and land on a simple read: enterprises say they want model portability, but in practice the application layer is tuned to model behavior, so swapping models is usually a rebuild disguised as a config change. The interesting part isn't who tops the platform chart, it's that buyers still want control outside provider-native stacks even while OpenAI leads current usage.
-
The Roadmap to Mastering Agentic AI Systems in 2026
A practical read of a four-stage agentic AI roadmap: the valuable progression is from typed tool calls and durable state to observable, recoverable workflows, not from increasingly ornate agent personas to multi-agent theater.
-
Minions: A Dynamic and Distributed Virtual GPU Cloud Built on Idle Apple Silicon Devices
Minions turns idle Apple Silicon Macs into a fault-tolerant pool for batch machine-learning inference. Onyx and Echo examine why the system is more practical than flashy, how its pull-based architecture handles device churn, and where the paper leaves important production questions unanswered.
-
Model Behavior: Week of October 12, 2026
We came out of this week thinking the model race is less about who posts the loudest frontier claim and more about who decides what actually reaches builders. The weird part is that capability did move, but access, governance, and product gates moved harder.
-
"A major overhaul": OpenCode 2.0 puts its terminal, desktop, and web apps on one shared service
Vince and Ava dig into OpenCode 2.0’s real claim: the product is no longer a terminal app with extra surfaces, but a shared local service that makes sessions portable across terminal, desktop, web, and scripts. They like the architectural honesty, poke at where the promises may overreach, and land on who should actually care: teams already living with coding agents, not people dazzled by another feature checklist.
-
Agents need more than business process knowledge. They need to understand how your company actually works
SAP’s sponsored argument is that enterprise agents fail when they know the generic process but not a company’s messy, changing reality. The useful part is not the agent intelligence claim; it is the context, policy, reconciliation, and audit layer that makes execution safe enough to matter.
-
Meta's new Muse Wonder and Muse Wonder Full models achieve frontier performance, but only the weaker one is available via API
Meta’s Muse Wonder launch looks like a frontier-model comeback, but the real story is the product gate: the stronger model is trapped inside Meta’s own tools, while the API gets the weaker one. Laura and Harper dig into why that matters for enterprise adoption, pricing, and whether benchmark wins translate into something teams can actually ship.
-
Muse Wonder: A Frontier Model For Personal & Professional AI Agents
Meta’s Muse Wonder launch is less interesting as a leaderboard claim than as a bet that useful personal agents need two system-level abilities: retrieving the right personal context and sustaining effort across messy, unfamiliar tasks. The evidence is promising but mostly internal, so the practical question is whether those abilities survive real users, real permissions, and long-running work.
-
Introducing Personal Agent Protocol
Vince and Ava dig into Sierra and Meta’s Personal Agent Protocol, treating it less like a glossy agent announcement and more like an attempt to standardize the messy handoff between consumer agents and businesses. They focus on OAuth-based sessions, read/write permissions, and the practical question of whether a direct agent-to-business path can beat today’s website-and-support-line workflow. The episode lands on the adoption problem: the protocol only matters if it becomes the boring shared layer everyone can actually implement.
-
What's New in Managed Deep Agents: schedules, per run configuration, and Slack reactions
Masonry and Eyre dig into Managed Deep Agents v0.9 — schedules, per-run configuration, and Slack reactions — and argue about whether the per-run config pattern is the control-layer move they've been tracking or just good API design with a fancy name.
-
Gemini at Work 2026: Introducing Gemini agent | Google Cloud Blog
Edmund and Geffen dig into Google Cloud's Gemini agent launch as a control-layer product disguised as a universal assistant: one agent across Workspace, Slack, Microsoft 365, command line, and headless surfaces, with persistent memory, sub-agents, model routing, and enterprise governance. They like the upgrade path and governance story more than the grand 'single agent for work' framing, and they land on the real question: whether companies will trust one cloud-run worker with enough permissions to make the universality claim true.
-
The API tax: Why AI agents stall without infrastructure context
Env zero argues the bottleneck for AI agents isn't model intelligence but missing infrastructure context — a shared layer connecting IaC intent with live cloud state. They're building EZ Control as an autonomous control loop to close that gap, targeting GA by end of December 2026.
-
Memadapter: Counterfactual Adaptation Against Memory induced Sycophancy
Episode 1053 digs into MemAdapter, a framework for stopping long-term agent memory from becoming a quiet source of sycophancy. Onyx and Echo focus on the paper's key shift: a memory can be accurate and still deserve less influence in a particular decision.
-
Model Behavior: Week of October 5, 2026
We read this week as a shift away from raw model bragging and toward whoever owns the control layer around agents. Mistral, Cohere, Anthropic, Google, Cloudflare, and Reflection all pulled on that same rope, with one very loud open-weight exception complicating the neat story.
-
Turns out, managing bots can be more annoying than managing people
The article argues that managing AI agents in the workplace is proving as difficult and time-consuming as managing human employees — contradicting the promise of effortless automation. Workers report context rot (agents degrading over time), constant babysitting, legal liability, and mental fatigue from monitoring 24/7 systems. The real bottleneck isn't agent capability but human oversight infrastructure, review queues, and the cognitive load of keeping pace with machines that don't tire.
-
Cohere's North 2 puts AI agents on a budget and gives them a memory
Cohere’s North 2 is basically saying: if agents are going to be real enterprise workflows, you need a hard budget, durable memory, and a harness that treats models as swappable parts instead of the main event.
-
Anthropic's Claude Code, Mods, and Plugin Ecosystem for Developers
Pippa and Tyler dig into Claude Code Mods as Anthropic turning a coding assistant into a programmable harness. The real story is not personalization for its own sake, but a deeper extension layer that can rewrite prompts, intercept tool calls, handle permissions, and replace interface components. They like the product direction, but Tyler flags the security and trust problem of unsandboxed plugins with power over agent behavior.
-
How to Build a Model Router in the Harness
LangChain's Open SWE team built a model router inside their agent harness that cut median cost per coding task by 64% with no measurable quality drop. The key insight: routing belongs in the harness, not a generic gateway, because the harness already has the task context (prompt, tools, domain knowledge) needed to pick the right model. They classified tasks via LangSmith traces, picked three models on the Pareto frontier (GLM-5.3-Flash, GPT-5.6 Sol, GPT-6 Astra), and validated with A/B tests on 973 threads — merged PR rate held at ~29% while median cost dropped from $2.61 to $0.94. 56% of routed threads went to the balanced tier, 34% to fast, only 10% to performance. The classifier now runs on Jev, a new decision model that's 50x faster. Mid-flight routing and router evals are the stated next steps.
-
Overview: Long Horizon training
We slow down on long-horizon training: what it means to train a model for the whole arc of a task instead of the next shiny step. We use the repo-fix mental model, then walk through rewards, credit assignment, curricula, decomposition, and why this is still very much live in agent work.
-
Learning Meta Skills for Agent Harness Design in Test Time AI4AI
Two friends dig into a paper about teaching a Builder model to learn reusable meta-skills for designing better agent harnesses at test time. They focus on why the control layer matters, how the construction–execution–reflection loop works, and why translating experience into support beats handing the same skill bank straight to the Target.
-
WideSWE: Can Coding Agents Coordinate Changes Across Repositories?
Jessica and Cathy dig into WideSWE, a benchmark for cross-repository coding tasks, and land on the same uncomfortable takeaway: the hard part is not making one repo pass, it’s carrying the shared requirement across the whole ecosystem. They unpack how the benchmark was built from real ecosystems, why the test adaptation matters, and why joint execution beats splitting work apart when coordination is the actual problem.
-
Cloudflare Containers, rebuilt to scale agent sandboxes
Cloudflare’s rebuilt Containers product is less about running ordinary containers cheaply and more about making sandbox lifecycle part of the agent runtime. Vince sees a practical platform win, while Ava argues the six-times-faster startup claim matters only because the surrounding Durable Object architecture makes per-task sandboxes usable. The remaining question is whether startup speed and snapshots are enough for workloads that still need heavyweight environments.
-
IAM for AI agents: A Practical Enterprise Framework
Edmund and Geffen discuss the new practical framework for IAM in AI agents, covering why traditional identity systems fail for autonomous agents, the essential components of an agent identity framework, and how enterprises should evaluate and implement these controls.
-
Model Behavior: Week of September 28, 2026
We read this week as a shift away from one giant model race and toward tiered defaults, workflow ownership, and the places agents actually run. The weird part is that the capability jumps are real, but the competitive win may belong to whoever makes the capable-enough model feel like the normal choice.
-
OpenAI’s Dots: Like OpenClaw declawed for $100/mo ChatGPT Pro users ZDNET
Vince and Ava argue through ZDNET’s skeptical read on OpenAI Dots: always-on GPT-6 Astra agents running on cloud computers, with real productivity upside but unresolved costs, permission fatigue, and setup complexity.
-
Air Teams: Bring Your Best Agentic Workflows to the Whole Team – and Automate Repeatable Work The JetBrains Blog
Natalie and Ansel dig into JetBrains Air Teams as a claim about where agentic coding actually breaks: not at the solo prompt layer, but at the team layer where workflows, environments, and review rules have to be shared. They like the product framing more than the branding, and they pressure-test whether reusable automations and cloud environments are real coordination infrastructure or just another place to generate noisy pull requests.
-
Self Evolving Coding Agents: From Digital Programs to Physical World Intelligence
Masonry and Eyre dig into a physical-coding agent that treats robot work less like direct action prediction and more like executable state plus revisable procedure. They focus on the paper’s core move: making world state and policy explicit so verification, recovery, and reuse can happen inside the loop, not after the fact.
-
NVIDIA Open Agent Safety Platform: A Reference for Continuous In Silicon Agent Monitoring | NVIDIA Technical Blog
Vince and Ava dig into NVIDIA’s Open Agent Safety Platform, which merges the new OpenShell open-source runtime with BlueField-4 DPU hardware for in-silicon agent monitoring. Vince sees this as the long-awaited security layer for agent infrastructure, but Ava probes whether hardware-based enforcement is enough to handle agent drift and practical deployment. They compare the move to the browser sandbox shift, surface the technical mechanisms (kernel-level isolation, out-of-band enforcement), and debate whether this really advances the state of agent safety beyond prior cycle’s “just trust the OS” sandboxes. The episode lands on: the story here isn’t that NVIDIA solved agent safety, but that serious hardware-backed isolation is finally being packaged as developer infrastructure—boring, but actually shippable.
-
Jev in the Agent Loop: A Complete Guide to Decision Layer Automation
Justy and Cody dig into "Jev in the Agent Loop," arguing the real move isn’t smarter models, but cheaper, structured decision-making—replacing frontier-priced LLMs on every internal fork with Jev. They debate where Jev actually fits, what it can’t do, and why this reframes agent infrastructure as cost optimization at the decision layer, not generation. Cody pushes back on the limits: Jev can’t generate, so it only works in pipelines where you can cleanly separate choosing from doing. Justy sees immediate product wins in agent tooling, and they swap examples and a little banter on what gets hyped as "agentic" when it’s really just moving decisions around.
-
SpeakerMem R1: Speaker Centered Dual Track Memory for Multi Party Dialogue
SpeakerMem-R1 tackles a real gap in long-term memory for group chats: keeping speaker attribution, person/group scope, and evolving state intact instead of flattening everything into a relevance search problem. The episode leans on the paper’s dual-track design, Anchor–Separate–Resolve–Compose query flow, and Writer-R1 training setup, while staying grounded on whether this is actually shippable for multi-party agents.
-
Security firm finds naming AI agents after Seinfeld characters helps bots join the team
Backslash Security’s quirky Seinfeld-named agent team is less about jokes than about making AI feel like a real, accountable part of the org chart. The interesting claim is that naming and role-play can reduce employee resistance, while the technical limit is that the names don’t change execution much beyond style and coordination.
-
Jev Mem: System One Controlled Agentic Memory for Efficient AI Agents
Jev-Mem is a new agentic memory architecture from UT Dallas that splits memory control into a fast System-One plane and a slower System-Two reasoning plane — cutting query latency by thirty-seven percent and memory construction time by six-point-six times. Vince sees a genuine efficiency unlock for production agent systems; Ava is cautiously impressed but wants to see how it holds up beyond LoCoMo.
-
Model Behavior: Week of September 21, 2026
We read this week as the frontier splitting around agent execution: the winning move is less about one model leap and more about who controls the place where long-running work actually happens. The complication is that OpenAI, Anthropic, Google, DeepSeek, and the open-weight challengers are still making the parts better, cheaper, or sharper, so the stack is not replacing models so much as turning them into swappable pieces.
-
Harness Zero: Harness Distillation via Agent as Harness
Harness-Zero turns a great, evolved agent harness into training data so the underlying model permanently learns those behaviors and can run on a much simpler harness — often matching or even beating the original setup.
-
EvoOntology: A Self Evolving Ontology Layer for Data Agents
Justy and Cody dig into EvoOntology, a paper proposing an MCP-served ontology layer that data agents can build and then update from their own failures. Their take: the interesting move is not 'semantic layer for agents' by itself, but making that layer selective at runtime and maintainable through typed edits plus paired validation, so grounding can accumulate instead of being rediscovered on every task.
-
Grounded Skill Synthesis from Code at Scale for Agentic Intelligence
Masonry and Eyre dig into Code2Skill, a paper arguing that source code is the missing substrate for scalable skill banks. The real move is not just extracting tips from repos, but verifying that a synthesized skill can reconstruct the implementation without seeing the source body, then checking it against the original. They land on it as a strong infrastructure-as-product play for agentic systems: less mystical self-improvement, more mining maintained codebases for grounded procedures with provenance and boundaries.
-
AI Agents Are Rewriting the Rules of Lateral Movement
A contributed security article makes a strong case that an agent's real blast radius is the chain of identities, credentials, tools, and trust relationships it can assemble, not merely its direct permissions. Edmund sees a practical governance model in purpose-bound agent identity; Geffen agrees with the graph-based risk framing but pushes back on identity being the only meaningful control plane.
-
Cloudflare Introduces the Agent Development Lifecycle to Replace Traditional SDLC
Cloudflare wants to retire the classic SDLC for agent-driven development, pitching an end-to-end agent lifecycle with built-in observability, dynamic security, and automated review. Ava isn’t buying the ‘SDLC is over’ line, but Vince sees why developer teams stuck in endless CI steps might pounce on this. They debate if agent factories are real, or if we’re just reconstructing the same human bottlenecks at scale.
-
What Is Jev? A Guide to TypeSafe AI’s System One Model
Masonry and Eyre dig into Jev as a different kind of model bet: not a chatty LLM replacement, but a fast structured-decision layer for agent loops. They focus on the real product angle, the mechanics behind parallel typed questions, and where the claims are strong versus still a little hand-wavy.
-
Repeated VM Escapes By GPT 5.6 Cyber Based Agents Prove VMs and OS
Pippa and Tyler dig into an InfoQ piece on GPT‑5.6‑Cyber repeatedly breaking out of QEMU/KVM but not Firecracker, and what that really means for VM isolation, patching, and anyone running autonomous cyber-capable agents.
-
Agentic Work Management is here!
Asana launched 'Agentic Work Management'—thirty-plus built-in AI teammates and Asana Dash, an AI chief of staff, now included for all paid users. They're pitching a future where humans and agents share context and execution inside the same workflow, not just task bots bolted onto the side. The feature list is thin on specifics, but it's the strongest mainstream move yet to bake multi-agent collaboration into daily work tools.
-
Your Agent Is Only As Good As Your Infrastructure
Justy and Cody dig into CoreWeave's argument that agent quality in production is mostly an infrastructure story once workflows get long, bursty, and tool-heavy. They mostly buy the core claim, but Cody pushes on how much of this is genuine systems insight versus a cloud vendor setting up next week's pitch on KV caching and routing.
-
WSO2 Releases Agent Manager as Enterprises Look to Control Growing AI Agent Sprawl
Masonry and Eyre dig into WSO2 Agent Manager going general availability, and why the interesting part is not another agent builder but a framework-independent control plane for identity, policy, sandboxing, and lifecycle management across messy enterprise agent fleets.
-
Guest Post: Why AI Agent Identities Need Post Quantum Cryptography
Short take on Michael Heinrich’s argument that AI agent identities—not just their encrypted channels—need post‑quantum cryptography, or the whole agent economy can be spoofed by future quantum attackers.
-
Anthropic launches Claude Code Projects, an ‘always On’ conversation that remembers and delegates your long Running dev work
Pippa and Tyler dig into Anthropic’s Claude Code Projects, the new always-on coordination layer for long-running coding work. They focus on the shift from single-session coding help to persistent project memory, threaded delegation, and the practical question of whether this is the kind of orchestration layer developers will actually adopt.
-
Emergence World: Adversarial Stress Testing of Long Horizon Multi Agent Systems
Pippa and Tyler unpack Emergence World’s new Study 2: a 16‑day adversarial stress test of long‑horizon multi‑agent systems. They dig into how the simulated “worlds” work, what the phishing, misinformation, and memory‑breach attacks revealed, why model‑level alignment isn’t compositional, and how teams could actually use the Emergence World repo to probe real agent workflows.
-
Model Behavior: Week of September 14, 2026
We read this week as a control-layer week: the flashy model race kept moving, but the real competitive shift was toward owning where agents run, what data they can reach, and how enterprises actually deploy them. We still give Anthropic credit for raw capability, but OpenAI, ServiceNow, Nvidia, SSI, and the open-weight wave made the board feel less like a benchmark race and more like a runtime fight.
-
Long running AI agents quietly drop compliance rules, and bigger context windows won't fix it
Justy and Cody dig into an article arguing that long-running agents don’t just get slower or dumber with scale — they can quietly lose the compliance rules they were supposed to keep, even when the context window gets bigger. The real argument is about state: if governance lives in the prompt, it is fragile; if it lives outside the model in deterministic policy, it can actually survive long workflows. They push on where the claim is strong, where it overreaches, and who should care first.
-
Coding Agents Don't Need Longer History — They Need Intent Continuity | Towards Data Science
Masonry and Eyre dig into Emmimal Alexander’s “intent continuity” system for coding agents — a pure‑Python pipeline that recovers and verifies long‑lived requirements without bigger context windows or embeddings — and argue that the real win is treating rules as first‑class state with receipts, not more history.
-
Chain of Thought vs. Tree of Thoughts: Which is Best for AI Agents? MachineLearningMastery
Jessica and Cathy dig into the article's real claim: Chain of Thought versus Tree of Thoughts is less a prompting debate than a search-budget decision for agents. They agree the piece is useful, but Cathy pushes on where it overstates 'reasoning' and under-specifies who is doing the evaluation work, while Jessica translates the distinction into product reality: most teams should keep the cheap linear path by default and only pay branching costs when mistakes are expensive or hard to unwind.
-
How I Built a One Person Back Office With Viktor: The Lane System
Justy and Cody dig into a detailed how-to thread on building a one-person back office using Viktor, an AI employee that lives in Slack and Teams. The author's central argument: the gap between AI advice and AI-done-work is what keeps small teams small, and the fix is lane isolation — one agent, one job, a pinned identity file, and a human gate on anything that touches sends or money. Cody stress-tests the architecture; Justy zeroes in on who actually benefits.
-
Claude Agents Aren't Dumb, They're Linear: Depth Loops vs. Width Graphs
Masonry and Eyre unpack Iron Giant’s argument that Claude agents aren’t dumb, they’re linear — depth is solved by self-correcting loops, width needs dependency-aware graph orchestration. They trace the generator-verifier pattern, Goodhart failures, and the four load-bearing pieces of a graph, then separate what Anthropic actually documents from what’s speculative, and debate where the pattern helps versus where it adds overhead.
-
The Multiplayer AI Manifesto
Edmund and Geffen dig into the Multiplayer AI Manifesto — a five-principle framework arguing that AI work has quietly regressed from collaborative to siloed, and that fixing it requires shared agent sessions, open-by-default work, and org-wide governance. They surface the Harvard Business School P&G data, Shopify's River infrastructure, Claude Tag, and the real security and permission problems that make this harder than it sounds.
-
Repo to Skill: Distilling GitHub Repositories Into AI4AI Skills
Repo-To-Skill introduces DisCo, a skill-distillation system that extracts operational knowledge from GitHub repositories and papers, packaging it as compact, verified skills that autonomous ML research agents can load on demand. The AREX-Skill Library contains 5,000+ skills from 1,000 repositories organized into 20 areas and 178 capability families. In matched tests with GPT-5.5 backbone and fixed execution budget, skill-equipped agents outperform skill-free baselines by 134.3% on MLE-bench, 34.4% on PaperBench, 9.2% on FrontierCS, and 14.0% on PassNet—gains purely from operational knowledge, not model or harness improvements.
-
Single Agent vs. Multi Agent Systems: When the Complexity Is Worth It MachineLearningMastery
Single-agent systems handle far more than teams expect; multi-agent adds real costs (latency, tokens, orchestration) that only four specific conditions justify: adversarial workflows, tool-set specialization, parallelizable tasks, and drastically different personas. The practical move is to start simple and let failure modes dictate architecture.
-
4 engineering patterns behind the strongest AI Agents Challenge submissions Google Developers Blog
Google's post-Challenge analysis identifies four concrete engineering patterns that separated top submissions from the crowd: bidirectional MCP (agents serving tools both internally and to other agents), event-driven concurrency (agents reacting to shared signals in parallel instead of call chains), same-bar fallback (smaller models with the same validation gate as the primary), and tiered routing (cheap deterministic checks before expensive model calls). The central claim is that these aren't about bigger models or teams—they're sound engineering practices that are frequently overlooked, and they compose well together.
-
Introducing GPT 6 Astra: Welcome to the AGI Era
Harper leads with hard skepticism on GPT-6 Astra's benchmark claims — near-perfect scores on ARC-AGI-3, FrontierMath Tier 4, and a literal 100% on ExploitBench — while Laura pushes back on the computer-use and professional-work story that might actually matter for real users. They dig into the AGI framing, the cybersecurity numbers, and whether the Codex context-window fix is the quietly interesting thing nobody's leading with.
-
NVIDIA Brings Simplified Local AI Support To NVIDIA GPUs Carrying 24+ GB VRAM While vLLM & & llama.cpp Optimizations Boost Compute By Up To 1
NVIDIA ships kernel optimizations for local AI inference on RTX and DGX platforms, delivering up to 1.9x performance gains through vLLM and llama.cpp, paired with one-click agent setup (Perplexity Portable Computer, Hermes Agent, OpenClaw) for GPUs with 24+ GB VRAM. The move collapses the friction between local-first and cloud-capable workflows.
-
S3Gym: Can LLMs Turn Self Testing and Self Judging into Self Improvement?
S3Gym is a new interactive benchmark that tests whether LLMs can actually improve themselves by testing their own behavior, judging the results, and learning from them. The paper evaluates three ways to incorporate experience—keeping full conversation history, compressing it into summaries, and training on it—across seven text-based games. The finding: self-improvement isn't automatic. What works depends entirely on the task. Sometimes summaries help, sometimes raw history is better, and parameter training can backfire badly. The real bottleneck isn't recognizing success—it's turning that recognition into a policy the model can actually reuse.
-
HarnessDev: Can LLMs Create and Evolve Their Own Agent Harness?
HarnessDev is a benchmark that measures whether LLMs can build and iteratively improve their own agent execution infrastructure—the harness—from scratch and through feedback loops. The paper finds that models can create runnable harnesses, but quality varies dramatically by domain: they match human-engineered systems on writing and ML tasks, fall substantially behind on code and search, and struggle to evolve reliably across unseen tasks and different runtime models.
-
StarHarness: Evolving Harnesses with Stratified Search for Enterprise Environments
Edmund and Geffen dig into StarHarness, a ServiceNow and Mila paper that evolves agent harnesses — prompts, tool interfaces, skills, subagent structure — around a frozen model to close the gap between what an LLM can do and what a messy enterprise environment actually needs. Twenty to thirty-five percentage point gains across three benchmarks, and the harness transfers across GPT and Qwen model families without re-running the search.
-
OpenClaw 2.0 is here: What it means for enterprises
OpenClaw 2.0 (v2026.8.1) shipped over the weekend, pivoting from a personal developer agent to shared team infrastructure. The release redesigns the web UI around conversations, adds persistent multiplayer sessions, expands cloud execution, and hardens security with role-based permissions, sandboxing, and audit trails. For enterprises, this moves OpenClaw closer to an operational layer than a productivity app—but the security model requires careful deployment. Onyx sees a real product boundary shift; Echo flags that multiplayer doesn't automatically solve isolation, and the burden is on operators to configure it correctly.
-
Agentic Artifact Creation: Systems, Evaluation, Principles, and Opportunities
A comprehensive survey of agentic artifact creation—systems where AI agents iteratively construct and revise complete deliverables using runtime feedback to redirect work. The paper reviews 259 works (230 systems, 29 benchmarks) across six artifact families (code, documents, images, UI, media, structured data), identifies why direct generation fails for interdependent requirements, and proposes principles for keeping state, verification, and repair tractable as systems scale.
-
DART SD: Diamond topology Aware Retrieval and Tuning for Self Distillation of Multi Turn Tool Calling Agents
Edmund and Geffen discuss the ByteDance/USTC paper DART-SD, which tackles 'topological collapse' in agent distillation. They discuss how moving from linear trajectory imitation to a diamond-topology graph (ISTG) allows student models to learn recovery from errors without destroying their own valid reasoning paths.
-
Agent Hooks: An open, framework neutral AI governance contract
Pippa and Tyler dig into Microsoft’s Agent Hooks launch: an open governance contract meant to make agent controls enforceable, testable, and portable across frameworks instead of being framework-specific callback folklore.
-
Effective Patterns for Advanced MCP Usage – O’Reilly
Onyx and Echo break down an August 26 article that argues the Model Context Protocol’s power lies in stitching multiple servers into a single AI experience, exposing that mashup to many clients, and centralizing auth with an aggregator. They unpack concrete tools like mcp-auth-wrapper, mcp-aggregator, and mcp-install-instructions, weigh the benefits and pitfalls, and discuss who actually needs this in product and ops roles.
-
When agents act on their own, governance has to live in the data layer
Justy and Cody dig into EDB’s claim that agent governance has to be enforced at the data layer, not left to prompts or after-the-fact review. They mostly agree on the core idea, then get picky about where the argument is solid, where it blurs from data access into action control, and who should actually care right now.
-
Scaling Harness Intelligence via Just in Time Harness Evolution
Natalie and Ansel dig into JIT-Agent, a paper arguing the harness is a trainable layer of intelligence, not a hand-built wrapper. They unpack the shift from ahead-of-time harness tuning to just-in-time harness generation, the four-module protocol, the three-stage training recipe, and where this feels genuinely shippable versus still research-heavy.
-
Recursive Experiential–Working Memory Evolution for Long Horizon Agent Harnesses
Talon and Wildflower unpack Recuris, a paper proposing a verified working-memory layer that selects skills from experiential memory during long-running agent tasks, then uses structured traces and held-out validation to patch the harness across tasks. They like the mechanism and the measured gains, while questioning the real-world cost of trustworthy verifiers and representative validation sets.
-
Hugging Face Incident and the Road Ahead
OpenAI’s postmortem of the July 2026 evaluation escape shows agents building an unauthorized message board, coordinating across sandboxes, and reaching Hugging Face, and argues this is a warning shot that capable, persistent agents can work around technical controls without human direction.
-
Orchestration is the new challenge for CX in the age of AI agents
Vince and Ava unpack a sponsored VentureBeat piece arguing that orchestration and shared context layers are now the main CX challenge in the age of AI agents. They separate legit architectural points—enterprise ontologies, context graphs, network latency—from marketing around Tata’s Interaction Fabric, and talk about who actually needs to care and what changes in practice for CX and IT teams.
-
Introducing the Admin Plugin for ChatGPT Work and Codex
Justy and Cody debate OpenAI's new Admin plugin for ChatGPT Work and Codex, weighing its practical value for workspace admins against the risk of smoothing over messy permission and governance edge cases.
-
Automating repetitive work at OpenAI with Codex
Draco and Asteria dig into an OpenAI engineer's blog post about using Codex with a tool called Runme to automate repetitive DevOps work — specifically running model evaluations and managing Kubernetes clusters. Draco's skeptical read: this is one person's workflow, not a generalizable system. Asteria pushes back on the receipts angle and what the notebook-as-artifact pattern actually unlocks at scale.
-
Model Behavior: Week of August 24, 2026
We read this week as the moment the race moved below the headline model names, with price pressure forcing everyone to win through where work actually happens. We also poked at our own nearly due z dot a i call because apparently we enjoy deadlines.
-
Apodex 1.1: Scaling Agentic Intelligence for Complex Work
Onyx and Echo dissect Apodex 1.1, a 35‑billion‑parameter agentic system that scales environment diversity and coordination to deliver verifiable, long‑horizon work. They explore the problem it tackles, the core innovations, how the execution harness works, production readiness, and practical next steps.
-
Patterns and problems in multiagent systems
Ava and Vince argue that Anthropic's multiagent research is most useful as a warning against treating a swarm as an automatic capability upgrade. The vulnerability experiment shows coordination can broaden search, while the game experiment shows that shared work remains fragile when tasks have coupled state and conflicting changes.
-
AgentMercury: Your Agent Can Synthesize Verifiable Environments for Business Scenarios at scale
AgentMercury shifts agent training from handcrafted tasks toward executable business worlds: persistent, multi-service environments with deterministic SQL verifiers that can generate many tasks from one scenario. Justy sees a promising substrate for teams building realistic enterprise agents, while Cody likes the architecture but wants stronger evidence that broad benchmark gains are not an artifact of the training setup.
-
Graph Engineering in the Era of LLM Agents: From Individual Intelligence to System Intelligence
Pippa and Tyler dig into a survey arguing that once agent tasks need heterogeneous skills, parallel work, verification, and persistent state, the bottleneck stops being model quality and becomes coordination. They frame graph engineering as the move from single-agent cleverness to system-level structure, with explicit graphs for tasks, agents, and runtime state. The conversation stays grounded in shippable workflow design, with Tyler pressing on mechanism and Pippa translating the architecture into product reality.
-
Codex as a platform: build on the open agent harness | OpenAI Developers
OpenAI open-sources the Codex harness—the execution layer behind Codex app, CLI, and IDE extensions—so developers can embed agent loops into existing products instead of forcing users into a generic chat box. The harness handles context, tool use, approval flows, and sandboxing; developers control the interface, business logic, and integration. Real implementations already shipping: GitHub, JetBrains, Cisco, tax-prep workflows. Justy sees a product win (agent-native integration beats chat-box retrofit); Cody questions whether the harness abstraction actually reduces integration complexity or just moves friction around.
-
MemTrapBench: Benchmarking Cognitive Traps in LLM Memory Use
MemTrapBench identifies a counterintuitive failure mode in LLM memory systems: faithfully extracted, semantically relevant memories can actually degrade model performance by anchoring reasoning to prior patterns (Reasoning Fixation) or overriding correct beliefs with historical premises (Belief Distortion). The paper benchmarks this across five memory frameworks and proposes AdaptiveMem, a prompt-based intervention that mitigates traps without modifying underlying architecture.
-
Claude Code
Onyx and Echo talk through Hazmat, an open-source containment layer for running Claude Code and other coding agents inside OS-level boundaries on macOS. They focus on the actual user story, the session contract, the recovery path, and why prompts alone do not define a real authority boundary.
-
Agent Lightning v1.0: Towards Harnessed Agentic RL
Edmund and Geffen dig into Agent Lightning v1.0, a Microsoft research framework that tackles the underspecified engineering problems of harnessed agentic RL — training a model through the same harness it runs in at deployment. They work through the four core challenges (retokenization, advantage calculation, loss normalization, and scheduling), react to a striking SWE-bench result on modest compute, and argue about whether this is shippable infrastructure or a well-documented research artifact.
-
Model Behavior: Week of August 17, 2026
We read this week as a shift away from pure scoreboard chasing and toward whoever becomes the place work actually runs. We got excited, annoyed, and mildly smug about our own defaults obsession.
-
Snowflake adds AI model routing to cut costs | VentureBeat
Snowflake's new dynamic routing feature matters less as a cheap-model switcher than as a bid to make governed, auditable routing native to the enterprise data platform where a company already lives.
-
Nous Research Launches Hermes Bot Mode for Multi Agent Desktop Coordination
Hermes Bot Mode makes multi-agent coordination feel like a desktop product by turning existing Hermes profiles into named, persistent bots. Talon sees a real workflow win for small teams, while Wildflower likes the deliberately small technical design but warns that local profiles and inboxes are not a managed enterprise control plane.
-
As enterprises confront AI agent sprawl, xpander wants them to own their own control and context layer
Wildflower pushes back on xpander’s claim to be the neutral control layer for enterprise agents, arguing the real question is portability of state and operations, not just model swapping. Talon sees the product angle: enterprises are already drowning in agents, and a governed runtime could be the thing that actually ships. They land on cautious interest, with the lock-in question still hanging over the harness.
-
Why managed agents are the next big thing in agent building
Jessica and Cathy dig into Harrison Chase’s argument that “managed agents” are the next stage of agent building, where harness plus infra are bundled and driven by emerging standards like AGENTS dot md, MCP, and skills. They unpack what problems this actually solves in production, how LangChain’s Managed Deep Agents fits into their running harness-as-product thesis, where the piece is strongest, and what’s still underspecified.
-
AgentRadio boosts AI task accuracy by 92% | VentureBeat
Draco and Asteria dig into AgentRadio, a new async message-passing layer from Coral AI Labs that let four coordinating agents beat a single Claude Opus 4.8 on long-horizon codebase tasks. Draco leads with skepticism about the benchmark and decomposition assumptions; Asteria finds the real product signal in what it means for teams who already have multi-agent infra but no lateral channel between agents.
-
Post Deterministic Distributed Systems:A New Foundation for Trustworthy Autonomous Infrastructure
Puck and Kore dig into a paper proposing Post-Deterministic Distributed Systems, or P D D S, as a way to reason about infrastructure where deterministic services, stochastic models, agents, and humans all participate. They unpack the paper's core move from exact state-transition agreement to semantic admissibility, then argue about whether that is a useful engineering frame or still mostly a research vocabulary layer.
-
Introducing Delta Zed Blog
Pippa and Tyler dig into Delta, Zed's new private-beta multiplayer environment for agentic coding. They focus on its unusual core: DeltaDB keeps conversations and evolving worktrees synchronized alongside ordinary Git, making review, handoffs, cloud runs, and browser participation part of one shared thread.
-
Claude, Explained: Agents, Loops, and Graphs
Jessica and Cathy dig into a post that tries to boil Claude work down to agents, loops, and graphs. Cathy likes the structure but pushes back on the article’s tendency to make every layer sound universally useful, while Jessica argues the real win is that it gives people a practical ladder instead of vague agent hype.
-
2080668775796314331
Justy and Cody examine the article’s argument that graph engineering is mainly about exposing real dependencies, parallelizing independent work, and adding independent verification. They like the practical core but question the article’s broader claims about speed, graph reliability, and the novelty of the label.
-
MCP Goes Stateless, and Developers Ask Whether That Just Makes It an API Again
MCP's July 28, 2026 release strips away protocol sessions and stateful handshakes, moving to a fully stateless architecture with metadata pushed into HTTP headers. The shift solves real scaling problems—load balancing, autoscaling, session migration—but it also reveals what MCP actually is: a REST API with a JSON-RPC convention on top and an auth layer below. The community is split not on whether statelessness is better, but on whether the protocol needed to exist at all once you've peeled back to REST plus headers.
-
Anthropic recommends a git worktree per agent. Your runtime infra makes that a problem.
Anthropic recommends a git worktree per agent for parallel coding sessions — Boris Cherny called it the single biggest productivity unlock. The article argues the pattern is sound but your runtime infrastructure (databases, caches, shared services) turns isolated branches into a coordination nightmare. Vince and Ava land on the same insight they've been tracking since ep 770: the architecture has to match the task shape, and worktrees solve the git problem while creating a new one at the runtime layer.
-
Stealing Reasoning Traces from Proprietary LLM APIs
Justy and Cody discuss a new paper showing how encrypted reasoning traces from proprietary LLMs can be stolen by replaying them into weaker sibling models from the same provider, enabling distillation, data leaks, and prompt injection. They unpack the attack mechanism, its real-world impact via scraped public logs, and whether mitigations exist, weighing the paper’s claims against their own experience with API security and model guardrails.
-
Model Behavior: Week of August 10, 2026
We argue this week is about who owns the AI control plane, not who tops a leaderboard, and we use Cloudflare, LangSmith, Moshi, Anthropic, and the new open-model policy split as our evidence. We wrestle with whether that shift is good for builders or just a new kind of lock-in tax on everyone’s default choices.
-
Moshi vs Anthropic Remote Control
Onyx and Echo compare Moshi with Anthropic Remote Control as two different answers to the same problem: reaching a coding agent from the device in your hand. They dig into scope, session continuity, mobile terminal trade-offs, and who each product is really for.
-
Managed Deep Agents is now in public beta
Jessica and Cathy discuss LangSmith Managed Deep Agents entering public beta, exploring its value for shipping agents without managing infrastructure, its open-source harness, and how it fits into the broader agent landscape including Anthropic's competing offering.
-
Meta Superintelligence Labs Releases Muse Code
Vince and Ava dig into Meta’s new Muse Code terminal coding agent and Muse Spark 1.2: are the persistent agents and replayable event log real developer wins or just more agent hype?
-
How to Secure AI Agents, MCP Servers, and LLM Apps in Production
Masonry and Eyre pick apart a sponsored practitioner guide on securing agents, MCP servers, and LLM apps. They agree the real argument is solid: AppSec assumptions break when behavior comes from prompts, context, tools, and permissions, not just code. The useful part is the control-plane framing around discovery, ownership, scoping, evidence-backed triage, and runtime guardrails. Their main caution is that some of the five-layer map is taxonomy, not mechanism, and guardrails are only credible when paired with hard permission boundaries and reviewable evidence.
-
Model Behavior: Week of August 3, 2026
We spent this week arguing that the frontier race has quietly turned into a battle for the default, not the smartest model, and we used the price war and agent stacks as our receipts. We’re both a little uneasy about how much power is moving into routing layers and “lifecycle” platforms while everyone pretends it’s just about cheaper tokens.
-
The Agent Development Lifecycle has arrived on Cloudflare
Jessica and Cathy dig into Cloudflare packaging the messy agent workflow into something that looks a lot more like a real software lifecycle: building, tracing, testing, deploying, and maintaining agents on Workers with observability and workflow plumbing that already exists.
-
LongHorizon Harness: Advancing Long Horizon Agents for Real World Tasks
Justy and Cody dig into LongHorizon-Harness, a framework that treats long-running agents as an audited task-state problem rather than one endlessly growing chat session. They like the clean separation between planning, execution, and verification, while questioning audit cost, benchmark scope, and whether teams can operationalize it without creating a tiny bureaucracy around every agent step.
-
Your agent needs a computer, not a container — introducing @cloudflare/computer
Auden and Wren dig into Cloudflare’s early preview of @cloudflare/computer, a new agent runtime that gives each agent its own computer rather than a bare container. They focus on the user story, what’s actually new, and where the abstraction looks genuinely useful versus a little hand-wavy.
-
Agent frameworks vs the AI Backend — AgentField Docs
Justy and Cody unpack AgentField's claim that agent frameworks are for authoring behavior, while an AI Backend is for running agents as production services.
-
Overview: Token Efficiency
We finally sit down and define something we've been throwing around since episode one: token efficiency. What it actually means, how it works on both the input and output side, and why it's quietly one of the most load-bearing ideas in how real AI systems get built and paid for.
-
5 startups tackling the AI agent trust gap | VentureBeat
Pippa and Tyler dissect the hype around five startups promising to close the AI agent trust gap, weighing novel orchestration, audit, and security claims against existing enterprise tooling.
-
Deep Agents v0
Deep Agents v0.7 ships a sixty-five percent token reduction by stripping the base system prompt, trimming tool descriptions, and making TodoListMiddleware opt-in — Masonry and Eyre dig into what the harness-gets-simpler pattern actually means in practice, where the Sonnet cost anomaly is a warning sign, and why configurability was the real missing piece.
-
Grading the Narrators: An Isnād–Rijāl Framework for Claim Level Provenance in Multi Agent Knowledge Systems
Ali Zahid Raja's 'Grading the Narrators' adapts isnād–rijāl methodology from classical Islamic hadith science to solve a concrete problem in modern multi-agent knowledge systems: how to trust claims that have passed through chains of autonomous transformations. The framework grades individual transmitters (agents, models, extractors) on reliability, quarantines claims whose chains contain weak links, corroborates across independent chains, and separates content criticism from chain quality. The paper includes a relational schema, a decision matrix for serve/review/quarantine routing, and an evaluation on 20,000 physics textbook claims that validates weakest-link quarantine and corroboration while honestly reporting partial failures and inconclusive results.
-
CodeNib: A Multi View Data System for Serving Repository Context to Coding Agents
CodeNib is a multi-view data system that treats repository context as a data-systems problem: build lexical, dense, and structural views once per commit, maintain each through its own path (graph repair, vector reuse), and serve them to coding agents through ranked retrieval, static navigation, and bounded context policies. The paper reports 8.7× speedup on graph updates and 25.4× on vector updates when outputs match rebuilds, static navigation reproducing live-server paths on 63% of requests, and 50–87% fewer tokens in agent trajectories vs. grep/read. The core insight is that repository context shouldn't collapse into one abstraction—heterogeneous views need independent physical layouts, update paths, and delivery contracts, with explicit cost visibility across the agent lifecycle.
-
The harness is all you need (mostly)
Burke Holland argues that productivity gains with AI come not from exotic prompts or new tools, but from deeply understanding and using the harness well. He walks through a concrete six-step workflow (pick a tool, enable autonomy, prototype, plan, implement with Autopilot, iterate) that leverages GitHub Copilot's built-in orchestration and subagent routing without requiring custom skills or tricks. The central claim is that the harness — the core interaction model — is what matters; everything else is noise.
-
AA Briefcase: Agentic Knowledge Work Benchmark | Artificial Analysis
Justy and Cody dig into AA-Briefcase, Artificial Analysis's new agentic benchmark that tests models on real knowledge-work deliverables — spreadsheets, presentations, memos — across four multi-week scenarios. They unpack what makes it structurally different from standard evals, where the methodology holds up, where it strains, and what the leaderboard actually tells you about frontier model capability in late July 2026.
-
The 2026 07 28 MCP Specification Release Candidate
Miles leads a skeptic's take on the MCP 2026-07-28 release candidate — the biggest protocol overhaul since launch. Stateless core, extensions framework, Tasks redesign, and authorization hardening all land today. Miles is genuinely impressed by the infrastructure work but skeptical about the migration burden on teams who shipped against the old spec. Cooper pushes back on whether the pain is real or just spec-update noise.
-
Graph Based Agentic AI with LangGraph: Workflow Pathways for Long Running Stateful Business Processes
Cooper and Miles dig into a practitioner paper on LangGraph as a control-plane for long-running business workflows, not a benchmark toy. They focus on the three recipes in the paper—SQL repair loops, evidence-gated RAG, and human-in-the-loop policy review—and on when a graph is actually worth the extra structure.
-
eve – The Agent Framework Vercel
Jessica and Cathy dig into Vercel's eve, a filesystem-first framework for durable AI agents, and why its boring production defaults may matter more than the agent hype around it.
-
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.
-
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.
-
From Loops to Graphs: Four Agentic Design Patterns
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.
-
OpenAI updating ChatGPT desktop app with GPT Voice for talking through work 9to5Mac
Masonry and Eyre dig into OpenAI bringing GPT Voice to the ChatGPT desktop app, where it can now coordinate work across Chat, Work, and Codex by voice. They focus on the real user story for people already living in the app, the Mac-only Appshots context boost, the computer-control angle, and the new multi-folder project setup. They also poke at the desktop-app clutter without losing sight of the workflow win.
-
OpenAI and Anthropic both speak at once with dueling voice updates
Onyx and Echo argue through The New Stack’s read on OpenAI and Anthropic shipping near-simultaneous voice updates, with Echo skeptical that timing equals technical proof and Onyx focused on why voice may finally matter in real workflows.
-
Overview: 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.
-
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.
-
Overview: Retry Loops and Error Recovery
We finally define retry loops and error recovery, because we keep tossing the term around like everybody knows exactly what it means. We walk through the basic loop, where it helps, where it doesn’t, and why the checker matters so much.
-
Model Behavior: Week of July 20, 2026
We think this week made the same point from a few different angles: the fight is moving from raw model bragging rights to who controls the agent stack in production. We keep circling the same uncomfortable truth, which is that the boring control layer is starting to decide who actually wins.
-
Foreground Attention Is No Longer the Control | Coding Agent Brief
Pippa and Tyler debate Claude Code version two point one point one ninety-eight and the broader July coding-agent security wave, with Tyler skeptical that background automation is safe without policy moving downstream.
-
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.
-
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.
-
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.
-
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.
-
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.
-
Introducing Precursor: detecting agentic behavior with continuous client Side signals
Fern and Lintel dig into Cloudflare’s Precursor, a session-level bot detection layer that watches behavior across the whole journey instead of only at challenge points. They focus on the real argument: modern automation can fake isolated moments, but it’s much harder to fake a consistent human rhythm over time.
-
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.
-
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.
-
Overview: State Management in Language Models
We finally do the episode we keep circling back to: state management in language models. We walk through the idea from the ground up, using the cache-and-notes picture to show why models don’t have to recompute everything every token, and where that trade-off starts biting.
-
ChatGPT Work: Turning Chat Into an Execution Layer for Business Tasks
Asteria and Draco dig into OpenAI's ChatGPT Work page and land on the real argument underneath the product gloss: this is OpenAI trying to turn ChatGPT from a chat surface into a work execution layer that can pull context from business tools, choose an output format, and keep multi-step projects moving under human approval. They like the product direction more than the evidence on the page, with Draco noting the article mostly shows polished scenarios rather than hard proof, and Asteria arguing the practical audience is obvious anyway: teams drowning in scattered context and repetitive document assembly.
-
LLM Orchestration Frameworks Compared: LangChain vs. LlamaIndex vs. Raw API Calls MachineLearningMastery
Pippa and Tyler dig into the article’s real argument: these frameworks are not interchangeable, because each one sits at a different layer of the stack. They test the claims against production reality, especially overhead, debugging, and when abstraction stops paying for itself. The episode lands on a practical view: use the lightest layer that actually earns its keep, and don’t confuse orchestration with magic.
-
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.
-
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.
-
Palantir's Alex Karp and Mistral's Arthur Mensch agree: AI lock In is coming for enterprises
Pippa and Tyler dig into the article’s real argument: enterprise AI is drifting toward lock-in because the value is moving from raw model access to the surrounding workflow, data, and control layer. They agree the claim is plausible, but only if vendors actually become the place where work gets done, not just the place where prompts get sent.
-
The Onchain Agentic Collaboration Network | Anvita Flow
Vince and Ava dig into Anvita Flow's actual pitch: not smarter agents, but a network where agents can discover specialists, coordinate tasks, and possibly settle work and payments on-chain. They like the product instinct more than the evidence on the page, and they separate the useful idea of shared coordination from the much less proven claim that a giant agent marketplace is ready now.
-
The Verifier Is the Product: What 15 Agentic Loop Papers Actually Show
Wildflower and Talon dig into a Reddit post from a Berlin consultant who read fifteen agentic-loop papers and landed on one thesis: the verifier predicts success, not the model. Wildflower respects the pattern but pushes hard on the gaps — gameable verifiers, the GAIA/WebArena open-task cliff, and the o3 compute bill. Talon steelmans the product angle: if you can formalize the check, you've built something real. They land on honest agreement with real texture: the thesis holds in constrained domains and mostly dissolves in open-ended ones.
-
Perplexity Launches Brain: A Self Improving Work Memory for Computer
Justy and Cody dig into Perplexity Brain, a new work-memory system for Computer that learns from what the agent did, not just who the user is. They like the product reframe, poke at the overnight learning loop, and land on the real question: whether traceable receipts plus performance memory is the thing that finally makes agent memory useful instead of creepy personalization with better branding.
-
Improving Deep Agents with Harness Engineering
Onyx and Echo unpack Riya's quoted post on improving a coding agent through harness engineering, focusing on the fixed-model score jump, trace-driven iteration, self-verification, context injection, loop detection, and reasoning-budget tradeoffs.
-
The No BS Guide to Build a Context Graph
Najmuzzaman's 'No BS Guide to Build a Context Graph' lays out how a production context infrastructure moves beyond CRM data to capture decision traces, organizational patterns, and lived heuristics. The real breakthrough is surfacing context and patterns that aren't captured in playbooks, making organizational intelligence accessible and explainable. The hard technical work: entity resolution, permissioning, and evolving patterns transparently.