AI Dev Team

Autonomous software development team powered by Claude AI agents

9 specialized AI agents collaborate as a real agile team — they plan sprints, write code, do code reviews, test, handle security audits, and manage deployments. Fully autonomous, 24/7, orchestrated by cron.

No API key needed — runs on Claude Code CLI with a Pro or Max subscription.

Demo

See it in action: We gave the team a one-paragraph brief to build a RAG application. It ran overnight and produced 28 user stories, 3,600 lines of code, 400+ tests, and 10 merged MRs on GitLab — all fully autonomously. See examples/rag-app/ for the initial brief and results.

What Makes This Different

Compared to other multi-agent frameworks (CrewAI, AutoGen, MetaGPT, OpenAI Swarm/Symphony), AI Dev Team takes a different approach — continuous autonomy across days and weeks, not just within a single session:

| | Other frameworks | AI Dev Team | |---|---|---| | Execution | One-shot task → result | Continuous, runs 24/7 via cron | | State | Lost between runs | Persistent board, sprints, backlog | | Collaboration | Task handoff within a session | Persistent cross-cycle reviews, QA testing, PO acceptance | | Planning | Human plans tasks | PO creates stories, PM assigns, team self-organizes | | Project management | External | Built-in sprints + GitLab/GitHub board sync | | Human input | Required per task | Write a brief, go to sleep, check results in the morning | | Dependencies | Heavy frameworks, API keys | Bash + Python + pyyaml, no API key |

How It Works

                    ┌─────────────────────────────────────┐
                    │       CRON (every 40 minutes)        │
                    │        orchestrator_cli.sh            │
                    └──────────────┬──────────────────────┘
                                  │
                    ┌──────────────▼──────────────────────┐
                    │        run_agent_cli.py               │
                    │   runs agents one by one              │
                    │   via claude --print --allowedTools   │
                    └──────────────┬──────────────────────┘
                                  │
          ┌───────────────────────┼───────────────────────┐
          │                       │                       │
          ▼                       ▼                       ▼
   ┌─────────────┐     ┌──────────────────┐     ┌──────────────┐
   │  🟣 Product  │     │   📋 Board       │     │ 🔗 GitLab /  │
   │    Owner     │◄───►│                  │◄───►│   GitHub     │
   ├─────────────┤     │  sprint.md       │     │              │
   │  🔵 Project  │     │  backlog.md      │     │  Issues      │
   │    Manager   │     │  standup.md      │     │  MRs / PRs   │
   ├─────────────┤     │  inbox/*.md      │     │  Comments    │
   │  🟢 Dev 1    │     │  decisions.md    │     │              │
   ├─────────────┤     │  architecture.md │     └──────┬───────┘
   │  🟩 Dev 2    │     └──────────────────┘            │
   ├─────────────┤                                      │
   │  🟠 DevOps   │     ┌──────────────────┐            │
   ├─────────────┤     │  🗂️ Git Repo     │◄───────────┘
   │  🔴 Tester   │────►│                  │
   ├─────────────┤     │  feature branch  │
   │  🛡️ Sec Team │     │  → push → MR    │
   │  (3 agents)  │     │  → auto-merge   │
   └─────────────┘     └──────────────────┘

One Cycle (~40 minutes)

PO reads the board, defines priorities and stories
PM coordinates the sprint, assigns work to developers
Dev1 + Dev2 implement features, write tests, review each other's code
DevOps handles Docker, infrastructure, deployment config
Tester runs functional reviews, verifies acceptance criteria
Git sync → feature branch → push → MR/PR → auto-merge
Board sync → issues updated on GitLab/GitHub

Agents communicate via inbox files — Markdown messages they send to each other. After each cycle, inboxes are archived and the next cycle starts fresh.

The Team

Core Team (runs every cycle)

| Agent | Role | What they do | |-------|------|-------------| | 🟣 Product Owner | Product strategist | Defines vision, writes user stories, prioritizes backlog, accepts/rejects work | | 🔵 Project Manager | Coordinator | Manages sprint, assigns stories to devs, resolves blockers | | 🟢 Developer 1 | Full-stack dev | Implements features, writes tests, reviews Dev 2's code | | 🟩 Developer 2 | Full-stack dev | Implements features, writes tests, reviews Dev 1's code | | 🟠 DevOps Engineer | Infrastructure | Docker, docker-compose, deployment, monitoring | | 🔴 QA Engineer | Quality | Functional review, testing, acceptance criteria verification, bug reports |

Security Team (runs separately, e.g. daily)

| Agent | Role | What they do | |-------|------|-------------| | 🛡️ Security Analyst | Security reviewer | OWASP Top 10 review, vulnerability analysis, security audit | | 🔐 Security Engineer | Security implementer | Implements security fixes, hardening, CSP/CORS | | 💀 Penetration Tester | Red teamer | Attack simulation, PoC exploits, attacker's perspective |

Quick Start

Prerequisites

Claude Code CLI — install with npm install -g @anthropic-ai/claude-code, then claude login
Claude Pro or Max subscription — Pro ($20/mo) handles minimal team, Max ($100/mo) recommended for full team
Python 3.10+ with pyyaml (pip install pyyaml)
Git (optional: GitLab or GitHub repo for full integration)
Isolated environment (recommended) — VM, LXC container, or Docker container

Important: The agents have access to shell tools and will create files, run commands, and modify the workspace. We strongly recommend running AI Dev Team in a dedicated, isolated environment (VM, LXC, Docker) to prevent unintended changes to your host system.

How it works under the hood: Each agent is executed via claude --print with a carefully crafted system prompt and context. The orchestrator calls Claude Code CLI for each agent in sequence — no API key needed, it uses your Claude subscription directly.

Setup

# 1. Clone and install
git clone https://github.com/CelaenoIndustry/OpenSepia.git
cd ai-team
pip install -r requirements.txt

# 2. Configure environment (optional — for GitLab/GitHub integration)
cp config/.env.example config/.env
# Edit config/.env with your tokens

# 3. Initialize a project
python3 scripts/init_project.py "My Project" "Description of what to build"

# 4. Run your first cycle
./scripts/orchestrator_cli.sh dev-team

Run Modes

| Mode | Command | Agents | Use case | |------|---------|--------|----------| | dev-team | orchestrator_cli.sh dev-team | 6 (core team) | Regular development | | minimal | orchestrator_cli.sh minimal | 3 (PO, Dev1, Tester) | Save rate limits | | security | orchestrator_cli.sh security | 3 (sec team) | Security audit | | all | orchestrator_cli.sh all | 9 (everyone) | Full team | | single | orchestrator_cli.sh dev1 | 1 | Debug a single agent |

Automated Runs (Cron)

# Dev team every 2 hours during work hours
0 8-22/2 * * * /path/to/ai-team/scripts/orchestrator_cli.sh dev-team >> /path/to/ai-team/logs/cron.log 2>&1

# Security audit once daily at 6:00 AM
0 6 * * * /path/to/ai-team/scripts/orchestrator_cli.sh security >> /path/to/ai-team/logs/cron.log 2>&1

Communication Model

Agents communicate via shared Markdown files on the board:

board/
├── sprint.md          ← Current sprint with stories and statuses
├── backlog.md         ← Product backlog with priorities
├── standup.md         ← Standup reports from each cycle
├── decisions.md       ← Architecture and technical decisions
├── architecture.md    ← System architecture
├── project.md         ← Project description and tech stack
│
└── inbox/             ← Messages between agents
    ├── po.md          ← Messages FOR the Product Owner
    ├── pm.md          ← Messages FOR the Project Manager
    ├── dev1.md        ← Messages FOR Developer 1
    ├── dev2.md        ← Messages FOR Developer 2
    ├── devops.md      ← Messages FOR the DevOps Engineer
    └── tester.md      ← Messages FOR the QA Engineer

How a cycle works:

Agent wakes up and reads its inbox + sprint.md
Processes messages and does its work (writes code, tests, reviews...)
Writes messages to other agents' inboxes
Updates sprint.md and standup.md
Its inbox is archived to board/archive/

Story Workflow

TODO → IN_PROGRESS → REVIEW → TESTING → DONE

PO creates a story with acceptance criteria
PM assigns it to a developer
Dev implements and sends for code review
Other dev does code review (approve/request changes)
QA functional testing + criteria verification
PO accepts or rejects

Sprint System

The project runs in sprints of 10 cycles (~7 hours of real time with 40-min intervals).

At the end of each sprint:

PO and PM run a retrospective
Sprint counter auto-increments
Board syncs with the new sprint

Integrations

AI Dev Team works standalone with just Markdown files on disk. But when you connect it to GitLab or GitHub, it becomes a full-featured development pipeline with issues, Kanban boards, merge requests, and auto-merge.

GitLab / GitHub Setup

Both are supported as interchangeable providers. Configure one in config/.env:

# Option A: GitLab
GITLAB_URL=https://gitlab.example.com
GITLAB_TOKEN=glpat-xxxxx
GITLAB_PROJECT_ID=group/project

# Option B: GitHub
GITHUB_TOKEN=ghp_xxxxx
GITHUB_OWNER=your-org
GITHUB_REPO=your-repo

The active provider is auto-detected from environment variables. If both are set

OpenSepia

Install / Use

README