Introduction

TL;DR: LegoFlow turns long-horizon agent data workflows into reusable, block-based pipelines that coding agents can run, inspect, and extend through plugin skills.

Building agent and software-engineering data pipelines is hard to do well. A realistic SWE pipeline has to mine useful GitHub changes, turn them into verifiable tasks, roll agents out in isolated environments, filter and convert trajectories, and then run multiple rounds of model training and evaluation. Without a shared workflow, the process becomes fragile: scripts drift, handoffs break, and several people often have to coordinate just to close the loop.

LegoFlow gives users a guided way to operate that full pipeline with coding agents. You can set up blocks, check inputs, launch runs, inspect dashboards, and extend the workflow through natural language instructions and plugin skills. Although LegoFlow starts from SWE data, its block-based design is built for broader long-horizon agent data workflows where tasks, rollouts, training, evaluation, and analysis need to evolve together.

Highlights

• Fully agentic data workflow: LegoFlow curates high-quality SWE tasks across 8+ programming languages and 20+ tags, then rolls out trajectories across multiple agent scaffolds, including Claude Code, OpenCode, OpenHands, and Terminus. The same workflow can grow into other long-horizon agent data domains.

• Live analytics dashboards: LegoFlow monitors the data production process through a series of live dashboards. These dashboards are built around carefully designed rubrics for tracking task difficulty, trajectory quality, and model performance.

• Easy to use and extend: LegoFlow is operated through agent plugin skills. These skills are tied to predefined blocks, making it easier to execute, modify, and extend the workflow without learning every script first.

System Design

The overall data pipeline is organized as a tree of blocks. A block is a contract for agentic workflows and one runnable unit in the pipeline. Each block owns its config, scripts, plugin skills, artifacts, dashboard, and pinned repository dependencies. The root block orchestrates four child blocks:

• curator: curates high-quality SWE and coding tasks from GitHub PRs, issues, and online forums such as Stack Overflow. Carefully designed filtering requirements preserve high-quality instances across 8+ programming languages and 20+ task tags.
• tracer: collects high-quality trajectories with verified rewards, supporting rollouts across multiple coding scaffolds such as Claude Code, OpenCode, OpenHands, and Terminus.
• trainer: converts rollout traces into training-ready formats and launches end-to-end training workflows.
• evaluator: measures checkpoints on coding benchmarks and supports detailed analysis with carefully designed rubrics and tags.

Why Blocks?

Blocks make the pipeline easier to use and easier to change. Because every stage follows the same contract, users can operate the whole system through plugin skills, restart a failed stage from its archived state, swap one block without breaking the others, and inspect artifacts through consistent dashboards. This keeps the workflow approachable for general users while leaving room for advanced analysis and new agent-data domains. See Block Design for the exact block anatomy and how the diagram maps onto the repository structure.

Where to go next

• Getting Started
• Block Design
• Block: curator · tracer · trainer · evaluator