AndAI — Summary

AndAI is a Go-based local tool that combines Redmine (ticket system) + Aider (AI coding agent) + configurable YAML-driven workflows into an end-to-end AI-assisted development system. The operator defines issue types (Epic, Story, Task, Bug), states, transitions, and workflow steps in a YAML config; AndAI then loops through tickets: pulling next unfinished work, building LLM context from ticket + comments + wiki + children/siblings, running AI coding commands via Aider, posting results back to Redmine as comments, and creating git branches per issue. The human reviews Aider's code changes in a browser UI and approves/rejects/edits each piece of work. Multi-model support is native: different LLM providers (Anthropic, OpenAI, Ollama, etc.) can be assigned to different workflow commands.

Compared to seeds: most similar to taskmaster-ai (workflow-driven task execution with AI) but dramatically more complex — full local stack (Docker Redmine + MariaDB + Aider), YAML-configurable workflows, multi-model routing per step, and a full web UI for review. Closer to a self-hosted Devin than a lightweight PM tool.

AndAI — Overview

Origin

Created by Andrejsstepanovs. 5 GitHub stars, Apache-2.0 licensed, Go, last commit 2025-07-08.

Philosophy

"A no-nonsense tool for organizing AI-assisted coding tasks for real-world developers."

"AndAI is a disposable, configurable tool that combines local ticketing with git branching to manage AI-assisted development tasks."

"By using this project you will be programmatically calling LLMs resulting in costs that you will be responsible for."

Key Principles

• Engineering accountability: "Your name will be under final code, so you will need to QA and groom it. AI just helps you with the heavy lifting."
• Structured git integration: every ticket and subtask gets its own git branch
• Controlled merging: changes merged only after explicit human approval
• Local-first: everything runs on your system — no cloud dependencies
• Disposable: set up in seconds, tear down just as quickly
• Offline capable: works with local or external LLMs

Architecture Metaphor

AndAI is closest in spirit to a "self-hosted Devin" — it loops through a ticket queue, gives Aider a ticket context + LLM, gets back code changes, posts them to Redmine, and waits for human approval. The workflow topology is configurable: different teams can define their own issue types, state machines, and LLM command assignments.

AndAI — Architecture

Distribution

Go binary + Docker Compose (Redmine + MariaDB):

# Download config templates
wget .andai.aider.yaml .andai.project.yaml docker-compose.yaml .redmine.env

# Start ticket system
docker-compose up -d

# Configure
andai setup all
andai validate config
andai ping all

# Work loop
andai work next

Required Runtime

• Go (for building binary)
• Docker + Docker Compose (for Redmine + MariaDB)
• Aider (AI coding agent)
• LLM API key (Anthropic, OpenAI, Ollama, etc.)

Directory Tree

<project-dir>/
├── .andai.aider.yaml         # Aider configuration
├── .andai.project.yaml       # AndAI project config (issue types, workflows, LLMs)
├── docker-compose.yaml       # Redmine + MariaDB setup
└── .redmine.env              # Redmine environment variables

<code-repo>/
├── main-branch/              # Primary code repo
└── branch-per-ticket/        # feature/bugfix branches per issue

Config Files

• .andai.project.yaml — main config: projects, issue types, workflows, LLM models
• .andai.aider.yaml — Aider-specific settings
• docker-compose.yaml — Redmine + MariaDB Docker setup

LLM Configuration Example

llm_models:
  - name: "normal"
    temperature: 0.2
    model: "claude-3-7-sonnet-latest"
    provider: "anthropic"
    api_key: "****"

Supported providers: anthropic, openai, cohere, groq, mistral, google, openrouter, deepseek, ollama (local), custom HTTP endpoint.

Target AI Tools

Aider (primary AI coding agent), any LLM provider.

Source Layout

internal/
├── ai/         # LLM integration
├── cmd/        # CLI commands
├── employee/   # Aider worker integration
├── exec/       # Command execution
├── redmine/    # Redmine API client
└── settings/   # Config management

AndAI — Components

CLI Binary: andai

Workflow Step Commands (defined in YAML config)

Context Sources (for LLM context building)

Configurable Workflow Example

workflow:
  issue_types:
    Story:
      description: "A specific functionality or component."
      jobs:
        In Progress:
          steps:
            - command: create-issues
              action: Task
              prompt: "Break this story into implementation tasks"
              context: [ticket, wiki]
            - command: ai
              action: analyze
              context: [ticket, children]
              remember: true
            - command: aider
              context: [ticket, comments]

Redmine Integration

Full Redmine REST API integration: issues, comments, branches, wiki, user management. Redmine serves as the visual review UI and audit log.

AndAI — Uniqueness & Positioning

Differs from Seeds

AndAI doesn't closely match any seed framework — it occupies a different tier of complexity. The most similar seed is taskmaster-ai (structured task workflow with AI execution) but AndAI is dramatically more heavyweight: it requires a local Docker stack (Redmine + MariaDB), uses Aider as the coding agent (not Claude Code/Codex), and implements a fully configurable YAML state machine for workflow definition. Unlike every seed framework (which are CLI tools or skill packs layered on top of existing AI tools), AndAI is a complete self-contained development environment. The multi-model routing per workflow step (different LLMs for different commands) is not found in any seed. The Redmine integration as both ticket system and review UI is unique.

Distinctive Positioning

• Only framework in this batch using Redmine as ticket backend (Jira-like but self-hosted)
• Aider as the AI coding agent (not Claude Code/Codex) — different agent ecosystem
• YAML-configurable state machine: operator defines issue types, states, transitions, and LLM assignments
• Multi-model routing per workflow step — unique in this batch
• remember: true flag for step-to-step context accumulation within a job
• Most complex local stack in the batch (Docker required)

Observable Failure Modes

• High setup friction: Docker + Go binary + Redmine + Aider + LLM keys required
• Very low adoption (5 stars) — likely niche use case
• Single-tenant design: one Aider job at a time
• Redmine is the bottleneck: if Docker is down, all work stops
• No path to GitHub/GitLab/Jira integration — Redmine is the only supported tracker