Welcome to Agiflow
Bridge your product development workflow with AI coding agents using proven patterns and standards
The Problem with AI Agents Today
AI coding agents are powerful, but as projects grow from MVP to production, they struggle with scale:
No conventions to follow
Agents generate thousands of lines of code that don't follow your team's patterns. Every file structure is different. Component naming is inconsistent. API routes don't match your REST conventions. You spend hours reviewing code that technically works but doesn't fit your codebase.
No coordination between agents
Multiple agents working in parallel create conflicts and duplicate work. One agent implements authentication while another adds a different auth library. Database migrations conflict. API contracts break. There's no shared understanding of the system being built.
No context retention across sessions
Agents lose context between sessions and start from scratch every time. You explain the architecture again. The agent re-reads documentation it already processed. Previous decisions are forgotten. Work Units with 6 related tasks become 6 isolated conversations with no memory.
No validation before merge
Code reaches production without programmatic checks against your architecture. Violations only surface in code review—after hours of agent work. You manually catch issues that should be automated: missing error handling, wrong file locations, skipped tests, violated design patterns.
The chaos compounds as your team grows and your codebase scales. A single missed convention becomes hundreds of files to refactor.
Agiflow's Approach: Bridging Agile Development with AI Execution
Agiflow is a web and API platform that connects your agile development methodology (epics, user stories, tasks, acceptance criteria) with AI coding agents. We solve this with two complementary layers:
Open Source: AI Code Toolkit
Our AI Code Toolkit enforces how agents build code. It's a collection of MCP servers and CLI tools that provide three capabilities:
1. Scaffolding Templates
Generate standardized code from templates instead of asking agents to write everything from scratch. Reduce 2000 lines of boilerplate to 200 with the right template.
Built-in templates:
nextjs-15-drizzle- Next.js 15 + App Router + Tailwind CSS 4 + Drizzle ORMtypescript-lib- TypeScript library with ESM/CJS builds and testingtypescript-mcp-package- Model Context Protocol server template
Fully extensible: Create custom templates for your stack. Templates use Liquid syntax for variable substitution.
2. Architecture & Design Patterns
Convention over configuration. Like Ruby on Rails or Angular, opinionated patterns make code predictable for both humans and AI agents.
Pattern enforcement through architect.yaml:
- File-based routing patterns for Next.js App Router
- Service layer patterns for business logic separation
- Repository patterns for data access
- Component composition patterns for React
How it works: Before writing code, agents call architect-mcp get-file-design-pattern to see applicable patterns with examples.
3. Rules & Validation
Pre-flight guidance tells agents what to do. Post-flight validation catches violations. Together, they ensure consistent output.
Rule categories in RULES.yaml:
- must_do: Required patterns (e.g., all async functions must handle errors)
- should_do: Best practices (e.g., prefer named exports for better tree-shaking)
- must_not_do: Anti-patterns (e.g., no direct DOM manipulation in React)
Validation workflow: After writing code, agents call architect-mcp review-code-change to get severity-rated feedback.
Tech Stack Agnostic: Works with Claude Code, Cursor, Windsurf—any MCP-compatible agent.
Framework Agnostic: Built-in templates for Next.js, TypeScript, MCP packages. Create custom templates for your stack.
Agiflow Platform: Agile Methodology Meets AI Execution
Agiflow transforms your agile workflow (user stories, acceptance criteria, sprint planning) into AI-executable work with coding standards enforcement:
1. Work Units: Epics and Features for AI Agents
Structure work the way agile teams do: epics contain features, features contain tasks. But instead of manual execution, AI agents read this structure and execute with full context.
Work Unit structure:
- Tasks: Atomic units of work with acceptance criteria (like user story acceptance criteria)
- devInfo metadata: Technical context that agents read (git worktrees, Docker containers, test results, previous agent sessions)
- Progress tracking: Hierarchical progress calculation across tasks and child work units (like sprint burndown charts)
Context retention: When agents resume, they read devInfo to understand git worktrees, previous session outputs, and test states. No re-explaining architecture or business requirements.
2. Agent-CLI: Connect Your Coding Agents
Launch Claude, Gemini, or any coding agent with task context from Agiflow. The CLI authenticates with Agiflow's backend and provisions MCP tools based on the task requirements.
Agent CLI capabilities:
agent-cli connect- Authenticate with Agiflow backend and launch daemonagent-cli claude --agent-session-id LXX-4- Launch with task context from Agiflowagent-cli claude --llm-provider chatgpt --llm-model gpt-5- Model routingagent-cli router- Switch models mid-session without restart
What happens: Agiflow backend reads the task's acceptance criteria, parent Work Unit context, and related tasks, then provisions appropriate MCP servers (scaffold-mcp, architect-mcp, project-specific tools).
3. Agent Members: Specialized Roles
Configure agents as organization members with custom prompts (backend dev, frontend dev, code reviewer). Each agent gets different MCP tool access based on their role and the task requirements.
How it works:
- Backend agent: Gets database tools, API scaffolding, and architecture validation
- Frontend agent: Gets UI component tools, route scaffolding, and style validation
- Code reviewer agent: Gets read-only access and architecture validation tools
Security: RBAC with 4 roles (Owner, Admin, Member, Agent), Docker sandbox isolation, per-agent MCP tool access controls.
4. Real-Time Dashboard
Single web UI to manage all Work Units, tasks, and agent sessions. See which agents are running, review their outputs, add feedback, and track progress—whether running 1 agent or 100 in parallel.
Observability features:
- Live session tracking: See which agents are running, which tasks they're working on
- Tool usage audit: Track which MCP tools agents called and with what arguments
- Progress visualization: Hierarchical progress bars for Work Units, features, and individual tasks
- Comment system: Add feedback directly on tasks. Agents read comments when resuming.
How It Works Together
Here's a typical workflow showing how Agiflow bridges agile development methodology with AI execution using the open-source toolkit:
Create Work Unit in Agiflow (Epic with Features)
Create a Work Unit in Agiflow's web UI: "Shopping Cart Feature" with 6 tasks (Add to Cart API, Cart UI Component, Checkout Flow, Payment Integration, Order Confirmation, Tests). Add acceptance criteria to each task.
Each task links to specific scaffolding templates and design patterns. Work Unit stores devInfo: git worktree path, Docker container ID, test coverage baseline. This follows agile methodology but designed for AI execution.
Launch Agent via CLI with Task Context
Launch agent-cli claude --agent-session-id LXX-45 --alias "backend-dev"
Agiflow backend reads task LXX-45's acceptance criteria, parent Work Unit context, and related tasks. It provisions MCP servers: scaffold-mcp (for generating API routes), architect-mcp (for reviewing code), and database tools (for this agent's role).
Agent Uses Toolkit MCP Servers
Agent calls scaffold-mcp use-scaffold-method to generate Next.js API route with boilerplate validation, error handling, and tests.
Then calls architect-mcp get-file-design-pattern to understand REST API patterns before adding business logic (cart calculations, inventory checks).
Validate with Rules
Agent calls architect-mcp review-code-change on modified files.
Validation catches: missing async error handling (must_do violation), no input sanitization (must_do violation), missing JSDoc (should_do suggestion). Agent fixes violations and re-validates until clean.
Review & Iterate in Agiflow Dashboard
You review in Agiflow's web UI. Code looks good but cart calculations need tax logic. Add comment: "Add tax calculation based on user location."
Restart agent with same session ID. Agent reads comment from task via Agiflow API, reads devInfo (worktree, previous test results), and resumes with full context. No re-explaining architecture or business requirements.
Key insight: The toolkit ensures code quality (how to build). Agiflow ensures coordination (what to build, which agent builds it, task tracking). Both are necessary for scaling AI agent workflows beyond toy projects. Think of it as agile methodology (epics, user stories, acceptance criteria) redesigned for AI execution instead of human execution.
Explore the Features
Work Units
Epics and features for AI agents. Group 5-8 tasks with persistent devInfo metadata. Agents resume with full context (worktrees, Docker containers, test states).
Multi-Agent Collaboration
Agent Members with specialized roles. Launch via agent-cli with session tracking, model routing (Claude, GPT-5, GPT-5 Codex), and shared MCP server access.
Security & Governance
RBAC with 4 roles (Owner, Admin, Member, Agent), Docker sandbox isolation, per-agent MCP tool access. Control who can use scaffolding vs production tools.
MCP Integration
scaffold-mcp, architect-mcp, and custom MCP servers provisioned per task based on agent role and security policies. Shared or isolated depending on requirements.
Try the Open Source Toolkit First
Get started with our AI Code Toolkit—no platform required. Works with Claude Code, Cursor, and any MCP-compatible agent. Use scaffolding templates and architecture validation in your local environment.
Ready to Bridge Agile with AI Agents?
Use Agiflow to transform your agile workflow (epics, user stories, acceptance criteria) into AI-executable work with the open-source toolkit for code quality and real-time observability.