AI-powered agents implementing the Dynamic Systems Development Method (DSDM) framework using the Claude Agent SDK.

• Full DSDM Workflow Automation - Run complete project lifecycle from feasibility to implementation
• 6 DSDM Phase Agents - Specialized agents for each phase of the methodology
• 6 Design & Build Specialized Roles - Granular control with Dev Lead, Frontend/Backend Developers, Testers
• Multiple LLM Provider Support - Anthropic Claude, OpenAI GPT, Google Gemini, Ollama local
• 3 Agent Execution Modes - Automated, Manual (approval required), or Hybrid (balanced)
• 3 Workflow Modes - Agent-writes code, provides tips, or assists with manual development
• Enterprise Integrations - Confluence for docs, Jira for task management, DevOps tools
• 28 DevOps Tools - Based on 14 Development Principles for CI/CD, testing, monitoring, infrastructure
• 42+ DSDM Tools - File management, code generation, testing, documentation, deployment

• Project Generation - Auto-create folder structures with code, tests, docs, config
• Code Generation - Write production-ready code for frontend, backend, and APIs
• Test Generation - Unit, integration, and E2E tests with coverage analysis
• Documentation Generation - PRD, TRD, API docs, architecture diagrams, user guides
• Prototype Creation - Build functional prototypes for user validation
• MoSCoW Prioritization - Automated requirement prioritization (Must/Should/Could/Won't)
• Jira-Confluence Sync - Auto-sync work items and status to documentation

• Interactive Menu System - Browse phases, configure agents, run workflows
• CLI Commands - Full command-line interface with 11 flags and options
• Programmatic API - Python library for custom automation
• Agent Mode Configuration - Per-phase or per-role execution settings
• Workflow Mode Configuration - Customize interaction styles (code writing, tips, manual)
• Requirements File Support - Build from Markdown, text, or DOCX files
• Quick Feasibility Checks - Rapid assessment with caching
• Output Formatting - Rich terminal UI with tables, panels, progress bars
• Multi-Provider LLM - Switch between Anthropic, OpenAI, Gemini, Ollama

• 8 Core DSDM Principles - Business focus, timely delivery, collaboration, quality, incremental build, iteration, communication, control
• MoSCoW Method - Must/Should/Could/Won't have prioritization
• Timeboxing - Fixed-duration iterations and sprints
• Iterative Development - Continuous refinement via feedback loops
• Prototyping - Early validation with working models

DSDM Agents provides a set of specialized AI agents for each phase of the DSDM methodology, plus a DevOps agent based on the Development Principles.

The Design & Build phase can be broken down into specialized roles for more granular control:

Each agent has specialized tools and can operate in Manual, Automated, or Hybrid mode, with configurable Workflow Modes for how agents interact with developers.

• Requirement analysis and parsing
• Technical feasibility assessment
• Resource and budget estimation
• Risk identification and mitigation
• DSDM suitability checks
• Quick feasibility with caching
• Project initialization

• Business process mapping
• Stakeholder analysis and documentation
• MoSCoW prioritization
• Architecture and system design
• Timebox and iteration planning
• Risk log management
• Detailed requirements documentation

• Prototype generation (HTML, React, etc.)
• Code scaffolding
• User feedback collection
• Requirements refinement
• Functional testing
• Iteration documentation
• Prototype validation

• Technical design documentation
• Production-ready code generation
• Automated testing (unit, integration, E2E)
• Code review and quality checks
• Security scanning
• Technical requirements documentation
• Multi-language support (Python, JavaScript, TypeScript)

• Deployment planning
• Environment setup
• Production deployment
• Smoke testing
• Rollback preparation
• Training material generation
• Stakeholder communication
• Operations handover documentation

• Testing & Quality (5 tools) - Run tests, check coverage, linting, security scans, code quality
• CI/CD & Automation (4 tools) - Pipelines, deployment, rollback, task automation
• Infrastructure (4 tools) - Provisioning, Terraform validation, containers, scaling
• Monitoring & Health (4 tools) - Health checks, monitoring setup, service status, chaos testing
• NFRs & Dependencies (4 tools) - Dependency analysis, performance testing, accessibility, validation
• Documentation (2 tools) - Architecture Decision Records, documentation generation
• Task Management (2 tools) - Track incomplete tasks, monitor toil
• Backup & Recovery (2 tools) - Database backups, restore testing

• Architecture design and decisions
• ADR (Architecture Decision Records) creation
• Code review and quality oversight
• Team coordination and planning
• Technical design documentation
• System design validation

• UI/UX component development
• React/Vue component creation
• Responsive design implementation
• Accessibility (WCAG) compliance
• Responsive testing
• CSS/styling frameworks support
• Component reusability patterns

• REST API development
• Business logic implementation
• Database schema design
• Integration implementation
• Data validation and sanitization
• Error handling and logging
• Multi-database support (PostgreSQL, MongoDB, etc.)

• Unit test generation
• Integration test generation
• E2E test creation
• Test coverage analysis
• CI/CD pipeline integration
• Test reporting
• Mock and fixture generation

• Performance testing and benchmarking
• Scalability testing
• Reliability and uptime testing
• Accessibility testing (WCAG)
• Load testing
• Security baseline validation
• NFR metrics reporting

• Security vulnerability scanning
• OWASP Top 10 assessment
• Penetration testing scenarios
• Security report generation
• Risk ranking and prioritization
• Remediation recommendations
• Security documentation

• Project listing and discovery
• Project initialization
• File read/write/append operations
• File copying and deletion
• Directory creation and listing

• Markdown generation
• API documentation (OpenAPI/Swagger)
• Architecture Decision Records (ADRs)
• Technical design documents
• User guides and manuals
• Training materials
• Deployment runbooks

• Function-level code generation
• Full project scaffolding
• Component generation
• API endpoint generation
• Database schema generation
• Configuration file generation
• Test file generation

• Confluence - Page creation/update, CQL search, page hierarchy, comments
• Jira - Issue creation, sprint management, bulk operations, MoSCoW tracking
• Jira-Confluence Sync - Automatic status propagation, issue-to-page mapping

• AUTOMATED - Tools execute without approval
• MANUAL - Every tool requires explicit user approval
• HYBRID - Critical tools require approval, others auto-run

• AGENT_WRITES_CODE - Agent generates code autonomously
• AGENT_PROVIDES_TIPS - Agent provides guidance without writing
• MANUAL_WITH_TIPS - Human writes code, agent advises

• Anthropic Claude - claude-sonnet-4-5, claude-opus-4-5 (default)
• OpenAI GPT - gpt-4o, gpt-4-turbo, gpt-3.5-turbo
• Google Gemini - gemini-2.5-pro, gemini-2.5-flash
• Ollama Local - kimi-k2-thinking, llama3.2, codellama, or any Ollama model

• Project folder structure creation
• Source code (production & test)
• Configuration files
• Documentation
• Architecture diagrams
• API specifications
• Deployment plans
• Training materials

• Organized under generated/<project-name>/
• Automatic directory creation
• Type detection (Python/Node)
• Version control ready (.gitignore, .env)
• Package configuration (pyproject.toml, package.json)

• Full-stack trading platform with 11 pages
• React frontend with TypeScript
• FastAPI/Node.js backend
• PostgreSQL + Redis stack
• Real-time data visualization
• Authentication system
• Portfolio management
• Options pricing engine
• Test suite included
• API documentation
• Docker support

• Python 3.10+
• Anthropic API key (or Ollama for local LLM)

1. Clone the repository:

cd dsdm-agents

1. Create and activate the virtual environment:

python3 -m venv env
source env/bin/activate  # On Windows: env\Scripts\activate

1. Install dependencies:

pip install -r requirements.txt

1. Configure your API key:

cp .env.example .env

Edit .env and add your Anthropic API key:

ANTHROPIC_API_KEY=your-api-key-here

Here are 3 example prompts to get you started with DSDM Agents:

python main.py --workflow --input "Build a task management application with user authentication, project organization, and team collaboration features. Users should be able to create tasks, assign them to team members, set due dates, and track progress with kanban boards."

This runs the full DSDM workflow:

1. Feasibility - Analyzes technical viability and resource requirements
2. Business Study - Defines requirements with MoSCoW prioritization
3. PRD/TRD - Creates Product and Technical Requirements Documents
4. Functional Model - Generates prototypes and validates with stakeholders
5. Design & Build - Develops production-ready code with tests
6. Implementation - Prepares deployment and documentation

python main.py --phase design_build --input "Add real-time notifications to the existing task management app. Include: 1) Push notifications for task assignments, 2) Email digests for overdue tasks, 3) In-app notification center with read/unread status, 4) User preferences for notification types. The app uses React frontend and Node.js/Express backend with PostgreSQL."

This runs only the Design & Build phase to implement a specific feature, generating:

• Technical design documents
• Production code for frontend and backend
• Unit and integration tests
• API documentation

python main.py --phase feasibility --input "Migrate our legacy monolithic e-commerce platform to microservices architecture. Current stack: PHP/Laravel with MySQL. Target: Node.js microservices with PostgreSQL and Redis. Must maintain 99.9% uptime during migration. ~500k monthly active users, 50k daily orders."

This runs the Feasibility phase to assess:

• Technical complexity and risks
• Resource requirements (team, timeline, infrastructure)
• Migration strategy options
• Go/no-go recommendation with justification

You can build applications from PRD (Product Requirements Document) or other requirements files stored in the docs/requirements/ folder.

If you have a Word document, convert it first:

pandoc docs/requirements/YOUR_PRD.docx -t markdown -o docs/requirements/YOUR_PRD.md

Run full DSDM workflow:

python main.py --workflow --input "$(cat docs/requirements/YOUR_PRD.md)"

Run specific phase:

python main.py --phase feasibility --input "$(cat docs/requirements/YOUR_PRD.md)"

Programmatic approach:

from src.orchestrator import DSDMOrchestrator, DSDMPhase

orchestrator = DSDMOrchestrator(
    include_devops=True,
    include_jira=True,        # Optional: track tasks in Jira
    include_confluence=True   # Optional: publish docs to Confluence
)

# Load requirements from file
with open("docs/requirements/YOUR_PRD.md", "r") as f:
    requirements = f.read()

# Run full workflow
results = orchestrator.run_workflow(requirements)

# Or run specific phases
result = orchestrator.run_phase(DSDMPhase.FEASIBILITY, requirements)
result = orchestrator.run_phase(DSDMPhase.BUSINESS_STUDY, requirements)

docs/requirements/
├── YOUR_PROJECT_PRD.md      # Product Requirements Document
├── YOUR_PROJECT_TRD.md      # Technical Requirements Document (optional)
├── feature_specs/           # Feature-specific requirements
│   ├── auth_feature.md
│   └── payment_feature.md
└── nfr/                     # Non-Functional Requirements
    ├── performance.md
    └── security.md

All generated artifacts are saved to generated/<project-name>/:

generated/
└── your-project/
    ├── docs/
    │   ├── FEASIBILITY_REPORT.md
    │   ├── BUSINESS_STUDY.md
    │   ├── PRODUCT_REQUIREMENTS.md
    │   ├── TECHNICAL_REQUIREMENTS.md
    │   └── architecture/
    ├── src/           # Production code
    ├── tests/         # Test files
    ├── config/        # Configuration files
    └── prototypes/    # Functional prototypes

Launch the interactive menu to explore phases and configure agents:

python main.py --interactive

This opens a menu where you can:

• Run specific phases
• Run the full DSDM workflow
• Access the Design & Build team (specialized roles)
• Configure agent modes (Manual/Automated/Hybrid)
• Configure workflow modes (Write/Tips/Manual)
• View available tools for each phase

Run a specific phase:

python main.py --phase feasibility --input "Build a customer feedback system"

Run the full workflow:

python main.py --workflow --input "Build an inventory management system"

Set agent mode:

python main.py --phase design_build --mode manual --input "Implement user authentication"

List all phases:

python main.py --list-phases

List all tools:

python main.py --list-tools

Run Design & Build phase from a TRD file:

python main.py --phase design_build --input "$(cat docs/requirements/YOUR_TRD.md)"

Run Design & Build with hybrid mode (recommended for production):

python main.py --phase design_build --mode hybrid --input "$(cat docs/requirements/YOUR_TRD.md)"

Run full workflow from a PRD file:

python main.py --workflow --input "$(cat docs/requirements/YOUR_PRD.md)"

Combine multiple requirement files:

python main.py --phase design_build --input "$(cat docs/requirements/TRD_MAIN.md docs/requirements/TRD_SLICES.md)"

from src.orchestrator import DSDMOrchestrator, DSDMPhase, DesignBuildRole
from src.agents import AgentMode, WorkflowMode

# Create orchestrator with all integrations
orchestrator = DSDMOrchestrator(
    include_devops=True,
    include_confluence=True,
    include_jira=True
)

# Run a single phase
result = orchestrator.run_phase(
    DSDMPhase.FEASIBILITY,
    "Build a real-time analytics dashboard"
)

print(f"Success: {result.success}")
print(f"Output: {result.output}")

# Change agent mode
orchestrator.set_agent_mode(DSDMPhase.DESIGN_BUILD, AgentMode.MANUAL)

# Change workflow mode
orchestrator.set_workflow_mode(DSDMPhase.DESIGN_BUILD, WorkflowMode.AGENT_PROVIDES_TIPS)

# Run full workflow
results = orchestrator.run_workflow(
    "Build an e-commerce platform",
    start_phase=DSDMPhase.FEASIBILITY,
    end_phase=DSDMPhase.FUNCTIONAL_MODEL
)

DSDM Agents automatically manages projects in the generated/ directory. All documentation, code, and artifacts are saved under this folder.

When running any phase, all files are organized under generated/<project-name>/:

generated/
└── my-project/
    ├── docs/
    │   ├── FEASIBILITY_REPORT.md      # From Feasibility phase
    │   ├── BUSINESS_STUDY.md          # From Business Study phase
    │   ├── PRODUCT_REQUIREMENTS.md    # PRD from Product Manager
    │   ├── TECHNICAL_REQUIREMENTS.md  # TRD from Dev Lead
    │   ├── FUNCTIONAL_MODEL_REPORT.md # From Functional Model phase
    │   ├── DEPLOYMENT_PLAN.md         # From Implementation phase
    │   ├── TRAINING_MATERIALS.md      # User training guides
    │   ├── HANDOVER_DOCS.md           # Operations handover
    │   ├── api/                       # API documentation
    │   ├── architecture/              # Architecture Decision Records
    │   │   └── decisions/
    │   │       └── 001-database-choice.md
    │   └── user-guides/               # End-user documentation
    ├── src/                           # Production code
    │   └── ...
    ├── tests/                         # Test files
    │   ├── unit/
    │   └── integration/
    ├── config/                        # Configuration files
    ├── prototypes/                    # Functional prototypes
    ├── README.md
    ├── .gitignore
    └── pyproject.toml / package.json

Before creating a new project, agents check if one already exists.

from src.tools.file_tools import list_projects_handler, get_project_handler, init_project_handler
import json

# List all valid projects (with src/, tests/, or config files)
result = list_projects_handler()
data = json.loads(result)

print(f"Found {data['count']} projects:")
for project in data['projects']:
    print(f"  - {project['name']} (type: {project['type']})")
    print(f"    Last modified: {project['last_modified']}")
    print(f"    Has tests: {project['has_tests']}, Has docs: {project['has_docs']}")

# List ALL directories (including non-project folders)
result = list_projects_handler(include_all=True)

# Get detailed info about a specific project
result = get_project_handler("my-app")
data = json.loads(result)

if data['exists']:
    project = data['project']
    print(f"Project: {project['name']}")
    print(f"Type: {project['type']}")
    print(f"Files: {project['file_count']}")
    print(f"Directories: {project['directory_count']}")
    print(f"Structure: {project['structure']}")
else:
    print(f"Project not found: {data['message']}")

# Create a new project (checks if exists first)
result = init_project_handler(
    project_name="my-new-app",
    project_type="python",  # or "node"
    include_tests=True,
    include_docs=True,
    include_config=True,
    include_infrastructure=False
)
data = json.loads(result)

if data.get('already_exists'):
    # Project already exists - returns existing info
    print(f"Project already exists: {data['message']}")
    print(f"Existing project info: {data['existing_project']}")
else:
    # New project created
    print(f"Created project at: {data['base_path']}")
    print(f"Directories: {data['directories_created']}")
    print(f"Files: {data['files_created']}")

# Force recreate an existing project
result = init_project_handler("my-new-app", force_recreate=True)

from src.orchestrator import DSDMOrchestrator, DesignBuildRole
from src.agents import AgentMode, WorkflowMode

orchestrator = DSDMOrchestrator()

# Run a specific role
result = orchestrator.run_design_build_role(
    DesignBuildRole.BACKEND_DEV,
    "Implement REST API for user authentication"
)

# Run the full Design & Build team in sequence
results = orchestrator.run_design_build_team(
    "Build a payment processing module"
)

# Run specific roles only
results = orchestrator.run_design_build_team(
    "Implement checkout flow",
    roles=[
        DesignBuildRole.DEV_LEAD,
        DesignBuildRole.FRONTEND_DEV,
        DesignBuildRole.BACKEND_DEV,
        DesignBuildRole.AUTOMATION_TESTER
    ]
)

# Configure role mode
orchestrator.set_role_mode(DesignBuildRole.PEN_TESTER, AgentMode.MANUAL)

# Configure role workflow mode
orchestrator.set_role_workflow_mode(DesignBuildRole.FRONTEND_DEV, WorkflowMode.MANUAL_WITH_TIPS)

Default execution modes by phase:

• Feasibility → Automated
• Business Study → Automated
• Functional Model → Automated
• Design & Build → Hybrid
• Implementation → Manual
• DevOps → Hybrid

Default execution modes for Design & Build roles:

• Dev Lead → Hybrid
• Frontend Developer → Automated
• Backend Developer → Automated
• Automation Tester → Automated
• NFR Tester → Hybrid
• Penetration Tester → Manual

Workflow modes determine how agents interact with developers:

Programmatic configuration:

from src.orchestrator import DSDMOrchestrator, DSDMPhase, DesignBuildRole
from src.agents import WorkflowMode

orchestrator = DSDMOrchestrator()

# Set workflow mode for a specific phase
orchestrator.set_workflow_mode(DSDMPhase.DESIGN_BUILD, WorkflowMode.AGENT_PROVIDES_TIPS)

# Set workflow mode for a Design & Build role
orchestrator.set_role_workflow_mode(DesignBuildRole.BACKEND_DEV, WorkflowMode.MANUAL_WITH_TIPS)

# Set workflow mode for all agents
orchestrator.set_all_workflow_modes(WorkflowMode.AGENT_WRITES_CODE)

Interactive menu: Select option 5 "Configure workflow modes" from the main menu to:

• Set workflow mode for all agents at once
• Configure specific phases individually
• Configure Design & Build roles individually

When using AGENT_PROVIDES_TIPS or MANUAL_WITH_TIPS modes, agents provide contextual best practices based on:

• Language detection: Python, JavaScript/TypeScript
• Framework detection: React, Node.js, FastAPI, Django, etc.
• Task analysis: Testing, security, API design, async patterns

Tips include:

• Code quality best practices
• Security recommendations
• Performance optimization
• Testing strategies
• Links to official documentation

Enable Confluence integration to create and manage DSDM documentation directly in Confluence.

1. Add Confluence credentials to .env:

CONFLUENCE_BASE_URL=https://your-domain.atlassian.net
CONFLUENCE_USERNAME=your-email@example.com
CONFLUENCE_API_TOKEN=your-confluence-api-token
CONFLUENCE_DEFAULT_SPACE=your-space-key

1. Get an API token from Atlassian API Tokens

2. Enable in your code:

orchestrator = DSDMOrchestrator(include_confluence=True)

Available Confluence Tools:

• confluence_get_page - Retrieve page content
• confluence_create_page - Create new pages
• confluence_update_page - Update existing pages
• confluence_search - Search using CQL
• confluence_get_space - Get space info
• confluence_add_comment - Add comments to pages
• confluence_create_dsdm_doc - Create DSDM-formatted documentation

Enable Jira integration to manage project tasks, user stories, and sprints.

1. Add Jira credentials to .env:

JIRA_BASE_URL=https://your-domain.atlassian.net
JIRA_USERNAME=your-email@example.com
JIRA_API_TOKEN=your-jira-api-token
JIRA_DEFAULT_PROJECT=your-project-key

1. Get an API token from Atlassian API Tokens

2. Enable in your code:

orchestrator = DSDMOrchestrator(include_jira=True)

Available Jira Tools:

• jira_get_issue - Get issue details
• jira_create_issue - Create tasks, bugs, stories
• jira_update_issue - Update existing issues
• jira_search - Search using JQL
• jira_transition_issue - Change issue status
• jira_add_comment - Add comments
• jira_get_project - Get project info
• jira_create_user_story - Create DSDM-formatted user stories with MoSCoW priority
• jira_create_timebox - Create sprints/timeboxes
• jira_bulk_create_requirements - Bulk create requirements
• jira_enable_confluence_sync - Enable automatic sync to Confluence
• jira_disable_confluence_sync - Disable automatic sync
• jira_sync_to_confluence - Manually sync an issue to Confluence
• jira_set_confluence_page_mapping - Map issue to specific Confluence page

When both Jira and Confluence integrations are enabled, you can automatically sync work item status changes to Confluence documentation.

Setup automatic sync:

from src.orchestrator import DSDMOrchestrator

orchestrator = DSDMOrchestrator(include_jira=True, include_confluence=True)

# Setup sync - this will:
# 1. Enable automatic sync for all Jira updates
# 2. Create a "Work Item Status Log" page in Confluence
result = orchestrator.tool_registry.execute(
    "setup_jira_confluence_sync",
    confluence_space_key="PROJ"
)

How it works:

• When you transition a Jira issue (e.g., "To Do" -> "In Progress"), the status is automatically logged to Confluence
• When you update a Jira issue, the changes are synced to Confluence
• A "Work Item Status Log" page tracks all status changes with timestamps

Workflow Tools (available when both integrations enabled):

• setup_jira_confluence_sync - Enable sync and create status page
• sync_work_item_status - Sync with DSDM phase context
• get_sync_status - Check current sync configuration

Map specific issues to documentation pages:

# Map a Jira issue to its design document in Confluence
orchestrator.tool_registry.execute(
    "jira_set_confluence_page_mapping",
    issue_key="PROJ-123",
    page_id="12345678"
)

# Now when PROJ-123 status changes, the design doc is updated

DSDM Agents supports multiple LLM providers. Configure your preferred provider in .env:

LLM_PROVIDER=anthropic
ANTHROPIC_API_KEY=your-api-key-here
ANTHROPIC_MODEL=claude-sonnet-4-5-20250929

pip install openai

LLM_PROVIDER=openai
OPENAI_API_KEY=your-api-key-here
OPENAI_MODEL=gpt-4o
OPENAI_ORG_ID=  # Optional

pip install google-generativeai

LLM_PROVIDER=gemini
GEMINI_API_KEY=your-api-key-here
GEMINI_MODEL=gemini-2.5-flash

1. Install Ollama

2. Pull a model:

ollama pull kimi-k2-thinking:cloud
ollama pull codellama  # For code-specific tasks

1. Configure in .env:

LLM_PROVIDER=ollama
OLLAMA_BASE_URL=http://localhost:11434
OLLAMA_MODEL=kimi-k2-thinking:cloud
OLLAMA_CODE_MODEL=codellama
OLLAMA_EMBEDDING_MODEL=nomic-embed-text
OLLAMA_TIMEOUT=120

from src.llm import LLMProvider, create_llm_client
from src.agents import AgentConfig, AgentMode

# Create agent with specific provider
config = AgentConfig(
    name="My Agent",
    description="Custom agent",
    phase="design_build",
    system_prompt="You are a helpful assistant.",
    llm_provider=LLMProvider.OPENAI,  # Use OpenAI for this agent
    model="gpt-4o",
)

# Or create a client directly
client = create_llm_client(LLMProvider.GEMINI)

orchestrator = DSDMOrchestrator(
    include_devops=True,
    include_confluence=True,
    include_jira=True
)

You can extend agents with custom tools:

from src.tools import Tool, create_dsdm_tool_registry

# Get the default registry (optionally with integrations)
registry = create_dsdm_tool_registry(
    include_jira=True,
    include_devops=True
)

# Add a custom tool
registry.register(Tool(
    name="my_custom_tool",
    description="Description of what the tool does",
    input_schema={
        "type": "object",
        "properties": {
            "param1": {"type": "string", "description": "First parameter"},
            "param2": {"type": "integer", "description": "Second parameter"}
        },
        "required": ["param1"]
    },
    handler=lambda param1, param2=0: f"Result: {param1}, {param2}",
    requires_approval=False,  # Set True for manual approval
    category="feasibility"    # Phase category
))

See examples/custom_tools_example.py for more details.

dsdm-agents/
├── src/
│   ├── agents/                    # DSDM phase agents
│   │   ├── base_agent.py          # Base agent class with workflow modes
│   │   ├── workflow_modes.py      # Workflow mode definitions and tips
│   │   ├── feasibility_agent.py
│   │   ├── business_study_agent.py
│   │   ├── functional_model_agent.py
│   │   ├── design_build_agent.py
│   │   ├── implementation_agent.py
│   │   ├── devops_agent.py
│   │   ├── dev_lead_agent.py           # Design & Build specialized
│   │   ├── frontend_developer_agent.py
│   │   ├── backend_developer_agent.py
│   │   ├── automation_tester_agent.py
│   │   ├── nfr_tester_agent.py
│   │   └── pen_tester_agent.py
│   ├── llm/                       # LLM provider abstraction
│   │   ├── __init__.py
│   │   ├── config.py              # Provider configuration
│   │   ├── base_client.py         # Base LLM client interface
│   │   ├── anthropic_client.py    # Anthropic Claude
│   │   ├── openai_client.py       # OpenAI GPT
│   │   ├── gemini_client.py       # Google Gemini
│   │   └── ollama_client.py       # Local Ollama
│   ├── tools/                     # Tool definitions
│   │   ├── tool_registry.py
│   │   ├── dsdm_tools.py
│   │   └── integrations/          # External integrations
│   │       ├── confluence_tools.py
│   │       ├── jira_tools.py
│   │       └── devops_tools.py
│   ├── orchestrator/              # Workflow management
│   │   └── dsdm_orchestrator.py
│   ├── utils/                     # Utility functions
│   │   └── output_formatter.py    # Terminal output formatting
│   └── docs/                      # Documentation
│       └── development-principles.md
├── examples/                      # Usage examples
├── generated/                     # Agent-generated project files
├── main.py                        # CLI entry point
├── requirements.txt
├── .env.example
├── GETTING_STARTED.md             # Comprehensive setup guide
└── README.md

DSDM (Dynamic Systems Development Method) is an agile framework based on 8 principles:

1. Focus on the business need
2. Deliver on time
3. Collaborate
4. Never compromise quality
5. Build incrementally from firm foundations
6. Develop iteratively
7. Communicate continuously and clearly
8. Demonstrate control

Key practices used by these agents:

• MoSCoW Prioritization: Must have, Should have, Could have, Won't have
• Timeboxing: Fixed time periods for delivery
• Iterative Development: Continuous refinement through feedback
• Prototyping: Early validation through working models

• analyze_requirements - Parse and structure requirements
• assess_technical_feasibility - Evaluate technical viability
• estimate_resources - Estimate team and budget needs
• identify_risks - Document project risks
• check_dsdm_suitability - Verify DSDM fit
• project_init - Create project folder structure
• file_write - Save feasibility report to generated/<project>/docs/

• analyze_business_process - Map current processes
• identify_stakeholders - Document stakeholders
• prioritize_requirements - MoSCoW prioritization
• define_architecture - High-level system design
• create_timebox_plan - Plan iterations
• update_risk_log - Maintain risk register
• project_init, file_write - Save reports to generated/<project>/docs/

• create_prototype - Build functional prototypes
• generate_code_scaffold - Create code structure
• collect_user_feedback - Gather stakeholder input
• refine_requirements - Update based on feedback
• run_functional_tests - Validate functionality
• document_iteration - Record progress
• project_init, file_write, file_read - Save prototypes and reports to generated/<project>/

• create_technical_design - Detailed designs
• generate_code - Write production code
• run_tests - Execute test suites
• review_code - Quality checks
• create_documentation - Technical docs
• security_check - Security scanning
• generate_technical_requirements_document - Create TRD
• project_init, file_write, file_read, directory_create - Save all code and docs to generated/<project>/

• project_list - List all existing projects in generated/ directory
• project_get - Get details of a specific project (structure, file counts, type)
• project_init - Initialize new project (auto-checks if exists first)
• file_write - Write content to files
• file_read - Read file contents
• file_append - Append to files
• file_copy - Copy files
• file_delete - Delete files
• directory_create - Create directories
• directory_list - List directory contents

• create_deployment_plan - Plan go-live
• setup_environment - Configure infrastructure
• deploy_system - Deploy to production
• run_smoke_tests - Verify deployment
• create_rollback - Prepare rollback
• execute_rollback - Revert if needed
• create_training_materials - User guides
• notify_stakeholders - Communication
• generate_handover_docs - Operations handover
• file_write, file_read, directory_create - Save deployment docs to generated/<project>/docs/

Testing & Quality: run_tests, check_coverage, run_linter, run_security_scan, check_code_quality

CI/CD & Automation: run_ci_pipeline, deploy_to_environment, rollback_deployment, automate_task

Infrastructure: provision_infrastructure, validate_terraform, manage_containers, scale_service

Monitoring & Health: health_check, setup_monitoring, check_service_status, run_chaos_test

NFRs & Dependencies: analyze_dependencies, run_performance_test, check_accessibility, validate_nfr

Documentation & Decisions: create_adr, generate_docs, track_decision

Task Management: check_incomplete_tasks, track_toil

Backup & Recovery: backup_database, test_restore

The repository includes a complete demo application - the OPTIX Trading Platform - built using DSDM Agents. This showcases what the agents can produce.

# From dsdm-agents root directory
./scripts/start_servers.sh

# Check status
./scripts/start_servers.sh status

# Stop all services
./scripts/start_servers.sh stop

• Frontend: http://localhost:3000
• API Docs: http://localhost:8000/docs
• Health Check: http://localhost:8000/health

See generated/optix/README.md for full documentation.

MIT