agentflow (berabuddies) — Summary

agentflow is a Python DSL and CLI tool for building and running multi-agent pipelines as explicit directed acyclic graphs (DAGs). It defines nodes as codex(), claude(), kimi(), or pi() agents connected via the >> operator, with fanout() for parallel expansion and merge() for batched aggregation. The >> syntax, combined with Jinja2 template interpolation of prior node outputs ({{ nodes.plan.output }}), makes prompt chaining explicit: one node's output literally becomes the next node's prompt input. It supports Codex, Claude, Kimi, and Pi (a router to 10+ providers including local Ollama/LMStudio) as execution targets, making it the most cross-provider orchestration DSL in the batch. Remote execution is natively supported: nodes can declare target={"kind": "ec2"} or target={"kind": "ssh"} to run on remote machines without extra setup. agentflow also auto-installs a skill for Codex and Claude Code so pipeline creation can itself be delegated to an agent. Compared to seeds: closest to taskmaster-ai in explicit DAG task decomposition, but agentflow is a general-purpose Python pipeline DSL (not task management), uses programmatic graph construction rather than AI-generated task trees, and uniquely supports cross-model cross-machine execution.

agentflow (berabuddies) — Overview

Origin

Created by shouc (GitHub: berabuddies/agentflow, also at shouc/agentflow per install script). Python package. 1,255 stars. License: MIT.

Philosophy

From the README description:

"Orchestrate thousands of agents and harnesses as a graph programmatically"

The framework is built around explicit graph construction: you write a Python script defining a DAG, then run it. The mental model is a data pipeline (nodes = agents, edges = data flow) rather than a team hierarchy.

Key design decisions:

1. Pipeline-as-code — graphs are Python files, version-controllable, reusable
2. Multi-model explicit — codex(), claude(), kimi(), pi() are distinct node types; mixing models in a pipeline is a first-class use case
3. Jinja2 prompt chaining — {{ nodes.plan.output }} interpolates previous outputs into prompts, making the data flow explicit
4. Remote execution built-in — EC2, ECS Fargate, SSH targets without extra infrastructure
5. Iterative cycles — review.on_failure >> write creates cycles for LLM-as-judge loops
6. Auto-installs its skill — curl ... | bash installs both the CLI and a Codex/Claude skill so the agent itself can build agentflow pipelines

Usage from README

from agentflow import Graph, codex, claude

with Graph("my-pipeline", concurrency=3) as g:
    plan = codex(task_id="plan", prompt="Inspect the repo and plan the work.", tools="read_only")
    impl = claude(task_id="impl", prompt="Implement the plan:\n{{ nodes.plan.output }}", tools="read_write")
    review = codex(task_id="review", prompt="Review:\n{{ nodes.impl.output }}")
    plan >> impl >> review

This three-node pipeline: Codex plans → Claude implements (using Codex's plan as prompt) → Codex reviews.

agentflow (berabuddies) — Architecture

Distribution

• Python package: agentflow (pip installable)
• Install: curl -fsSL https://raw.githubusercontent.com/shouc/agentflow/master/install.sh | bash (also installs Codex and Claude Code skills)
• Or manual: python3 -m venv .venv && pip install -e .[dev]
• CLI binary: agentflow
• Required runtime: Python 3.x

Directory structure (package)

agentflow/
  __init__.py       # Public API exports (Graph, codex, claude, pi, fanout, merge)
  dsl.py            # Python DSL (Graph context manager, NodeBuilder, >> operator)
  agents/
    base.py         # AgentAdapter base class
    codex.py        # Codex CLI adapter
    claude.py       # Claude Code adapter
    kimi.py         # Kimi CLI adapter
    pi.py           # Pi routing adapter (10+ providers)
    registry.py     # Agent type registry
  orchestrator.py   # Pipeline execution engine
  cli.py            # agentflow CLI entry point
  graph_optimizer.py # DAG optimization
  loader.py         # Pipeline file loader
  runners/          # Execution backends
  cloud/            # EC2, ECS, SSH remote execution
  skills.py         # Auto-install skill for Codex/Claude

skills/             # Codex/Claude Code skill files (auto-installed)

Config

No global config file. Per-graph configuration via Graph() constructor arguments:

Graph("name", concurrency=4, max_iterations=10, use_worktree=False, fail_fast=False)

Target AI tools

Codex, Claude Code, Kimi, Pi (router to Anthropic/OpenAI/Groq/Cerebras/xAI/DeepSeek/Gemini/ OpenRouter/Bedrock/Ollama/LMStudio). Cross-tool portability: high.

agentflow (berabuddies) — Components

Python DSL primitives

Fanout types

• fanout(node, int) — N identical copies
• fanout(node, list) — one copy per item in list
• fanout(node, dict) — Cartesian product over axes

CLI commands

agentflow run pipeline.py             # Run a pipeline file
agentflow run pipeline.py --output summary  # Run + show summary output

Agent adapters (4)

• CodexAdapter — generates TOML config, calls codex app-server
• ClaudeAdapter — wraps Claude Code CLI
• KimiAdapter — wraps Kimi CLI
• PiAdapter — routes to any provider via Pi's OpenAI-compatible/Anthropic-compatible wire API

Skill (auto-installed)

The install script deploys a agentflow skill to Codex and Claude Code that allows natural language pipeline creation:

codex "Use agentflow to fan out 10 codex agents, each telling a unique joke..."

Remote execution targets

• ec2 — auto-discovers AMI, key pair, VPC; zero-config
• ecs — ECS Fargate; auto-discovers VPC, builds agent image
• ssh — arbitrary SSH host
• shared — shared instance across multiple pipeline nodes

agentflow (berabuddies) — Uniqueness & Positioning

Differs from seeds

No direct match among the 11 seeds. agentflow is the only programmatic DAG DSL in the corpus. All seeds use markdown files, YAML configs, or natural language prompts to define workflows. agentflow uses Python code with operator overloading (>>).

Key differentiators:

1. Python DSL with >> operator — graph construction is code, not config. Versioned, testable, composable via Python modules. No other framework takes this approach.

2. Fanout/merge semantics — fanout(node, list), fanout(node, int), fanout(node, dict) (Cartesian product) provide structured parallel expansion. The {% for r in fanouts.review.nodes %} Jinja2 pattern for aggregating results is unique in the corpus.

3. Cross-model + cross-machine in same pipeline — mixing codex(), claude(), pi() nodes targeting different providers AND different machines (EC2/ECS/SSH) in a single with Graph(): block. No other framework treats multi-model + remote execution as equally first-class.

4. Iterative cycle with on_failure >> — back-edges (review.on_failure >> write) create structured LLM-as-judge loops with configurable max_iterations. The success_criteria field provides automated exit conditions without human intervention.

5. Self-bootstrapping skill — the install script deploys a skill so the agent can build and run agentflow pipelines, making the framework meta-capable (agents building agent pipelines).

Observable failure modes

• No persistent memory — pipelines are stateless; learning across runs requires external storage
• No human approval gates — fully automated by default
• The Python DSL requires programming knowledge; less accessible to non-developers
• Remote execution requires AWS credentials or SSH access
• No web dashboard for pipeline monitoring

Competitive positioning

agentflow targets developers who want to express multi-agent workflows as code, mix models in a single pipeline, and run agents on remote infrastructure. It fills the CI/CD-pipeline niche for AI agent orchestration — closer to Airflow or Prefect for AI agents than to Claude Code plugins.