Topic
Task Decomposition
36 episodes
-
2095402931721842694
Justy and Cody dig into a detailed how-to thread on building a one-person back office using Viktor, an AI employee that lives in Slack and Teams. The author's central argument: the gap between AI advice and AI-done-work is what keeps small teams small, and the fix is lane isolation — one agent, one job, a pinned identity file, and a human gate on anything that touches sends or money. Cody stress-tests the architecture; Justy zeroes in on who actually benefits.
-
2089274302617022464
Masonry and Eyre unpack Iron Giant’s argument that Claude agents aren’t dumb, they’re linear — depth is solved by self-correcting loops, width needs dependency-aware graph orchestration. They trace the generator-verifier pattern, Goodhart failures, and the four load-bearing pieces of a graph, then separate what Anthropic actually documents from what’s speculative, and debate where the pattern helps versus where it adds overhead.
-
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 Hermes Bot Mode
Hermes Bot Mode makes multi-agent coordination feel like a desktop product by turning existing Hermes profiles into named, persistent bots. Talon sees a real workflow win for small teams, while Wildflower likes the deliberately small technical design but warns that local profiles and inboxes are not a managed enterprise control plane.
-
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.
-
2087163793558126997
Vince and Ava dig into a post arguing that Kimi Agent Swarm’s real trick is not 300 parallel agents by itself, but turning their outputs into a connected context graph that compounds over time. They test the claim against their running thesis about harnesses, receipts, and selective structure.
-
2080668775796314331
Justy and Cody examine the article’s argument that graph engineering is mainly about exposing real dependencies, parallelizing independent work, and adding independent verification. They like the practical core but question the article’s broader claims about speed, graph reliability, and the novelty of the label.
-
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.
-
Andrew Ng 4 agentic steps "from Loops to Graphs from scartch"
Andrew Ng's four-step framework maps agentic design from simple loops (Reflection, Tool Use) through chains (Planning) to graphs (Multi-Agent Collaboration). The central claim: architecture beats model selection—GPT-3.5 in a reflective workflow hits 95.1% on HumanEval vs. GPT-4 zero-shot at 67%. Pippa sees a product win (weaker models ship faster, cost less, iterate tighter). Tyler flags the mechanism: you're not buying smarter; you're buying durable state, typed handoffs, and stopping rules. Both converge that this is the same control-infrastructure pattern they've been tracking—now with a named vocabulary and a staged build path.
-
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 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.