Agentic SDLC Forge: A Multi-Agent Software Development Lifecycle Framework

Agentic SDLC Forge is a CLI-driven initialization tool that solves context overflow and hallucination problems of large language models in code generation through role-based multi-agent workflows and a dynamic knowledge base. Its core idea is to build a virtual development team, integrate AI capabilities into the Software Development Lifecycle (SDLC) in an orderly manner, and improve the reliability and efficiency of AI-assisted development through strict role division and context boundary control.

With the application of large language models in software development, directly feeding large codebases and vague task descriptions easily leads to issues like context overflow, attention distraction, violation of architectural specifications, and hallucination dependency. Traditional AI programming assistants (e.g., Aider, Claude Code) are powerful but lack structured workflow constraints, making them prone to losing direction in complex projects. Agentic SDLC Forge was thus designed as a complete multi-agent SDLC pipeline rather than a simple code completion tool.

Virtual Development Team Architecture

• Orchestrator: Lightweight model (Claude Haiku) drives a state machine (planning → execution → verification → repair loop), responsible for state routing to reduce operational costs.
• Planner: Strong model (Claude Sonnet/Opus) decomposes user stories into atomic task lists, outputting goals, files, and acceptance criteria.
• Executor: Lightweight model works with the Aider tool, processing only the current task's limited file set to achieve bounded context control.
• Verifier: Strong model runs tests/lint/build, classifies failures, and triggers repair loops (limited retries).
• Reporter: Generates Markdown reports including task completion status, Token consumption, etc.
• Event Log: .forge/runs/<run_id>/events.jsonl serves as the single source of truth, recording agent events.

Dynamic Knowledge Base

Multi-level specification system: core principles (coding standards), domain context (generated from business interviews), architecture rules (platform-specific specifications), Git workflow rules, dynamic file tree—ensuring AI gets just the right context.

1. Bounded context over large context: Each agent only gets necessary content to avoid information overload.
2. Structured agent communication: Contracts are defined using validation patterns to prevent prompt injection and ensure predictability.
3. Cost optimization: Cheap models for routing (orchestrator), expensive models for judgment (planner/verifier).
4. Hard retry limits: Avoid infinite loops and resource waste.
5. Tool replaceability: Rules and knowledge base are pure Markdown, tool-agnostic, adapting to different LLM providers.

• Runtime: Python 3.11+.
• Dependencies: Aider (must be in PATH, installed via uv/pipx), Git (must be in PATH).
• Operating System: Supports Linux/macOS; Windows adaptation is a Stage9 work item.
• Local LLM support: Provides Ollama-based docker-compose.yml and start_llm.sh, supporting offline operation of models like Qwen, Gemma, Llama.

1. Role-based division of labor: Models with different capabilities perform their respective duties, improving efficiency and reducing error rates.
2. Context management first: Strict boundary control allows medium models to perform well in specific tasks.
3. Structured processes: Limit AI uncertainty through clear contracts.
4. Value of knowledge precipitation: The dynamic knowledge base continuously accumulates project specifications, which is more durable than single code generation.

Agentic SDLC Forge effectively solves core problems of large model code generation through virtual development team division, context boundary control, dynamic knowledge base, and event-driven architecture. For teams looking to systematically integrate AI into their development processes, it is an open-source project worth researching and trying.