Topic
Task Decomposition
58 episodes
-
Introducing Flint Recursive
Recursive Flint is an open-weight, local coding model that combines sparse MoE computation with a heavily optimized inference stack. Its real story is less the self-improving-AI framing than the attempt to make capable agentic coding fast, private, and practical on personal hardware.
-
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.
-
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.
-
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.
-
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.
-
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.
-
Overview: Chain of Thought
We finally slow down and explain chain-of-thought from the ground up: why making a model show its work can improve reasoning, when it helps, and where it still breaks. We keep it concrete with the examples we’ve looked at and the version of the idea that’s actually shipping now.
-
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.
-
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.
-
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.
-
Adversarial Review: Structured Disagreement for Grounded Agentic Code Review
Jessica and Cathy dig into Adversarial Review, a minimal reviewer–critic protocol for agentic code review that beats bigger multi-agent setups by forcing disagreement to stay structured and evidence-grounded.
-
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.
-
BI Agent and BI Bench: Towards Automating End to End Business Intelligence
Jessica and Cathy dig into BI-Agent and BI-Bench, a paper that tests whether language models can automate the messy end-to-end workflow behind business intelligence dashboards. They focus on the gap between natural-language SQL demos and real BI work: table selection, transformations, joins, and analysis over messy Power BI-style projects. Jessica sees a practical product path for internal analytics teams, while Cathy is impressed by the benchmark design and tool-augmented architecture, with caveats about dashboard-derived ground truth and public-data leakage.
-
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.
-
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.
-
Overview: Error Accumulation in Generation
We finally slow down and explain error accumulation in generation from the ground up — why mistakes compound as a model writes more tokens, how exposure bias sets the trap, and what actually helps.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
Kimi Agent Swarm's Real Trick: 300 Agents Building a Connected Context Graph
Vince and Ava dig into a post arguing that Kimi Agent Swarm’s real trick is not 300 parallel agents by itself, but turning their outputs into a connected context graph that compounds over time. They test the claim against their running thesis about harnesses, receipts, and selective structure.
-
2080668775796314331
Justy and Cody examine the article’s argument that graph engineering is mainly about exposing real dependencies, parallelizing independent work, and adding independent verification. They like the practical core but question the article’s broader claims about speed, graph reliability, and the novelty of the label.
-
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.
-
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.
-
Deep Agents v0
Deep Agents v0.7 ships a sixty-five percent token reduction by stripping the base system prompt, trimming tool descriptions, and making TodoListMiddleware opt-in — Masonry and Eyre dig into what the harness-gets-simpler pattern actually means in practice, where the Sonnet cost anomaly is a warning sign, and why configurability was the real missing piece.
-
Advanced Context Engineering for Coding Agents/benchmarking Opus 5 on Slop Code Bench.md at main · humanlayer/advanced Context Engineering for Coding Agents
Vince and Ava dig into a hands-on benchmark run from the HumanLayer repo — Opus 5, Opus 4.8, and Sonnet 5 put through SlopCodeBench, a checkpoint-based coding benchmark from UW Madison that withholds requirements iteratively. Opus 5 wins technically at 24% strict pass rate, but nobody finished clean, and the code quality metrics tell a story about how models degrade over long-horizon tasks.
-
Overview: Directed Acyclic Graph
We finally slow down on directed acyclic graphs, or D A Gs, because this one quiet structure keeps showing up under workflows, agents, build systems, and half our control-stack arguments. We make it click as a map of prerequisites: arrows for order, no loops, and a scheduler that can see what can run now.
-
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.
-
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.
-
Overview: Durable Execution
We’re finally slowing down and unpacking durable execution from the ground up, because it keeps showing up in our conversations and it actually deserves the full treatment. We’re using the book-with-bookmarks idea to make the mechanics of checkpoints, retries, and recovery click without hand-waving.
-
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.
-
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.
-
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.
-
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.
-
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.
-
Managing AI Investments in the 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.
-
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.
-
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.
-
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.
-
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.