Agent Garden: A Multi-Agent Development Workflow Framework Based on Claude Code

Agent Garden is a multi-agent development workflow framework built on Claude Code. It drives agent collaboration via a file suffix state machine, enabling end-to-end automation from requirements analysis to acceptance, and provides a reproducible workflow model for engineering AI-assisted development. Its core mechanism is the file suffix state machine, which coordinates the division of labor among specialized agents (such as requirements analysis, architecture design, code implementation) to advance the development process.

AI-assisted development tools are evolving from "code completion" to "end-to-end automation". Currently, an engineered multi-agent collaboration model is needed to automate the complete development cycle. The Agent Garden project was thus proposed to address this need and provide a structured multi-agent development workflow.

File Suffix State Machine: File suffixes carry workflow states and correspond to different agent roles and tasks, such as .req.md (requirements analysis), .design.md (architecture design), .impl.py (code implementation), etc. Multi-Agent Collaboration Architecture: Includes requirements analysis agents (parsing requirements into structured specifications), architecture design agents (outputting system architecture blueprints), code implementation agents (generating code using Claude Code), test writing agents (generating and running tests), and review and acceptance agents (quality control).

The workflow progresses through changes in file suffixes: initial requirements document → design document → implementation code → test code → review document → marked as completed. This mechanism has four key advantages:

1. Observability: States are reflected in the file system, no additional database required;
2. Recoverability: Failures can be restarted from the current state;
3. Auditability: Change history is recorded via version control;
4. Extensibility: Adding new agents only requires defining new state suffixes and rules.

The framework is built on Claude Code, with integration points including:

• Code generation: Using Claude's code-writing capabilities to implement functions;
• Code understanding: Analyzing code via Claude for review and refactoring;
• Natural language processing: Parsing requirements and generating documents;
• Tool invocation: Integrating with file systems, test runners, Git, etc.

Engineering considerations of the framework:

• Balance between determinism and creativity: The state machine provides a deterministic process framework, while agents retain creative space internally;
• Human intervention points: Configurable human intervention at key nodes (e.g., review, design confirmation);
• Error handling: Retry, rollback, or escalate to human handling in case of failure;
• Parallel and serial coordination: Independent functions are developed in parallel, while dependent functions are executed serially.

The value of Agent Garden lies in providing a reproducible and extensible AI-assisted development workflow model. Application scenarios include:

• Standardized development processes: Establishing unified team norms;
• Automation of repetitive tasks: Template-based development of similar functions;
• Rapid prototyping: Quickly validating ideas into runnable code;
• Learning and teaching: Demonstrating best practices for AI-assisted development. The project is in the early stage with clear core concepts, serving as a reference architecture for exploring multi-agent collaborative development.