GitHub Win4r/team tasks: Multi agent pipeline coordination: Linear, DAG, and Debate modes for AI agent orchestration

Izzo You know that moment when you're trying to coordinate three different AI agents on the same feature and they're all stepping on each other's work?

Izzo You're listening to Exploring Next, episode 174. I'm Izzo, and with me is Boone. Today we're digging into team-tasks — a Python CLI that actually solves multi-agent coordination without the usual orchestration nightmares.

Boone I've been waiting for something like this. Every time I try to run agents in parallel, I end up with this mess of custom scripts and state tracking. What's the real problem this is solving?

Izzo Think about it from a product perspective. You want to ship a feature that needs API implementation, tests, docs, and security review. Right now you either run agents sequentially — which is slow — or you try to coordinate them manually, which is chaos.

Boone Right, and the coordination problem gets exponentially worse. You need dependency tracking, state management, and some way to handle when Agent A finishes before Agent B but Agent C needs both their outputs.

Izzo Exactly. So team-tasks gives you three distinct coordination patterns. Linear mode for simple sequential work, DAG mode for complex dependency graphs, and — this is clever — debate mode for multi-agent deliberation.

Boone Okay, let's start with the DAG mode since that's where the real complexity lives. How does the dependency resolution actually work?

Izzo So you define tasks with explicit dependencies using the add command. Like, you might have 'implement' depend on both 'design' and 'scaffold'. The system builds a proper dependency graph and validates for cycles upfront.

Boone That's smart — fail fast on circular dependencies. But the interesting part is dispatch. When you run 'ready', it returns ALL tasks whose dependencies are satisfied. So you can fire off multiple agents simultaneously.

Izzo And here's the product genius — when any task completes, the system automatically detects what gets unblocked downstream. No manual orchestration. You just keep polling 'ready' and dispatching whatever comes back.

Boone The depOutputs feature is crucial too. When a task becomes ready, it includes the actual output from its dependencies. So if Agent A produces an API spec, Agent B gets that spec as input, not just a notification that it's done.

Izzo Which brings us to the OpenClaw integration. This isn't just a standalone tool — it's designed as a skill for agent orchestration systems. The AGI dispatches through sessions_send and tracks state through the CLI.

Boone I love that they kept the core as a simple Python script with zero external dependencies. Just stdlib, stores state as JSON files. You can drop this into any environment without dependency hell.

Izzo The linear mode is actually brilliant for its simplicity. You define a pipeline order — like 'code-agent, test-agent, docs-agent' — and it auto-advances through stages. Perfect for bug fixes or straightforward feature development.

Boone But debate mode is where this gets really interesting. You send the same question to multiple agents with different roles, collect their positions, then run a cross-review phase where each agent sees the others' work.

Izzo It's like structured code review but for any kind of decision. Security audit, architecture choice, even technical documentation. Each agent brings their perspective, then they review each other's findings.

Boone The synthesis step is key — you end up with all initial positions plus cross-reviews in one place. Much better than trying to manually coordinate three different agent conversations.

Izzo From a market angle, this hits the sweet spot between simple task runners and full orchestration platforms. Teams that are outgrowing basic agent scripts but don't want the complexity of Kubernetes-style orchestrators.

Boone The CLI design is really well thought out. Commands like 'graph' to visualize your DAG, 'log' to add context during execution, 'history' to see what happened. It feels like a proper development tool, not just a coordination layer.

Izzo And the status tracking is clean — pending, in-progress, done, failed, skipped. Simple state machine but with enough granularity to handle real workflows. I'm giving this a solid A-minus for execution.

Boone The error handling around common pitfalls is nice too. Like warning you that stage IDs are agent names, not numbers. Or preventing you from adding debaters after rounds start. Those are the details that matter in production.

Izzo What's your take on the JSON storage approach? Some people might want a proper database.

Boone Honestly, I think they made the right call. JSON files are debuggable, portable, and you can version control them. For agent coordination, you don't need ACID transactions — you need visibility and simplicity.

Izzo Plus the environment variable override for storage location means you can adapt it to different deployment patterns. Whether you're running locally or in a containerized environment.

Boone This is definitely going on my weekend project list. I want to try the DAG mode with some ML pipeline coordination. Maybe training, validation, and deployment agents working in parallel.

Izzo So here's what to go build next. First, clone the repo and try the linear mode with a simple three-agent pipeline. Code, test, docs — something you can actually complete.

Boone Second, experiment with the DAG mode. Set up a project with real dependencies and watch how the ready command changes as tasks complete. The parallel dispatch pattern is the key insight here.

Izzo And third, if you're doing any kind of agent-based code review or decision making, try debate mode. Start with two agents giving different perspectives on the same technical question. The OpenClaw integration docs are worth reading even if you're not using that specific platform. The dispatch loop patterns apply to any agent orchestration system. This is the kind of tool that makes multi-agent development actually practical instead of just theoretically possible. We'll be wat