devflow

Inspiration

I kept hearing about multi-agent orchestration, but most of the available solutions felt like demos, terminal wrappers, or fixed agent teams. I could not find a tool that let me turn development work into visual graphs, save those graphs as reusable workflows, and manage them throughout a real software- development lifecycle.

That gap inspired DevFlow.

The project is based on the workflow I use in my current development work: define a task, delegate it, review the result, verify the evidence, make the necessary human decisions, and pass useful context to the next task. I wanted orchestration to feel less like supervising multiple terminals and more like managing a coherent engineering process.

## What it does

DevFlow is a local-first command center for AI coding agents. It lets developers:

• Run standalone development tasks with Codex.
• Connect tasks into sequences with automatic handoffs.
• Create reusable workflows represented as directed graphs.
• Add intelligent routing nodes that choose the next step dynamically.
• Configure models, reasoning levels, repositories, MCP servers, and completion criteria for each task.
• Isolate work using managed Git worktrees or temporary repositories.
• Review and integrate agent changes through explicit human approval gates.
• Observe conversations, execution events, token usage, estimated costs, checks, and Git evidence from one interface.
• Control the same system through both a web application and an agent-friendly CLI.

Instead of asking developers to constantly watch their agents, DevFlow brings them back only when a meaningful decision is required.

## How I built it

I built DevFlow as a TypeScript monorepo with a React interface, a Fastify API, and a CLI that exposes the same capabilities as the UI. The backend follows a hexagonal architecture so that orchestration rules remain independent from the interface, persistence layer, and AI provider.

Codex and GPT-5.6 were deeply involved throughout the Build Week. I used them to explore product decisions, implement and refactor features, design APIs, write tests, investigate failures, and review changes. During the event, DevFlow was meaningfully extended with reusable routed workflows, managed scratch workspaces, live workspace exploration, a complete Git worktree review lifecycle, improved agent-delivery verification, and additional provider support.

One interesting aspect of the project is that DevFlow also helped coordinate parts of its own development. This created a practical feedback loop: every friction point I experienced while building with agents became an opportunity to improve the product.

## Challenges

The hardest part was not launching multiple agents. It was making their work reliable and understandable.

Agent executions produce many events, can be interrupted, and may continue for a long time. DevFlow therefore needed persistent conversations, resumable runs, queued messages, real-time updates, and a clear separation between technical activity and information that actually requires human attention.

Git isolation was another major challenge. Agents need freedom to modify code, but developers must remain in control of what reaches the main branch. I built a managed worktree lifecycle that supports isolated implementation, checkpointing, independent review, conflict detection, refresh when the target branch changes, and explicit approval before integration.

Finally, presenting graphs, tasks, conversations, checks, costs, and review states without overwhelming the developer required several design iterations. The goal was always to show the next useful action, not every possible detail.

## What I learned

I learned that useful agent orchestration is not primarily about running more agents in parallel. It is about structuring responsibility, context, evidence, and decisions.

A reusable graph becomes valuable when each node has a clear purpose, receives the right handoff, and produces evidence that the next node—or the developer—can trust. Human involvement is still essential, but it should happen at deliberate decision points instead of through constant supervision.

DevFlow is the tool I wanted for my own work, and I believe it can help other developers move from isolated AI coding sessions to repeatable, observable, and trustworthy development workflows.

Built With

• codex
• fastify
• git
• gpt-5.6
• mcp
• node.js
• openai
• playwright
• react
• typescript
• vite
• vitest