Autonoma – AI-Assisted Dev Platform

An AI-driven development platform that assists with software project management, planning, and deployment configuration.

Overview

Autonoma uses specialized AI agents to handle the complete software development lifecycle:

• COORD – Coordinator & Project Manager
• ANALYST – Requirements & UX
• TECHLEAD – Architecture & Stack
• DEVTEAM – Development + Testing
• SHIPPER – DevOps & Delivery
• SENTRY – Logging, Metrics & Alerts

Features

• Non-technical Dashboard: Simple interface for operators to manage client projects
• AI-Powered Proposals: Automated generation of project proposals with MVP/Standard/Extended options
• Automated Architecture: TECHLEAD agent designs appropriate tech stack based on requirements
• Milestone Planning: DEVTEAM creates structured development milestones
• Assisted Deployment: SHIPPER generates deployment configurations, Docker Compose files, and deployment instructions (manual deployment required)
• Health Monitoring: SENTRY tracks project health, budget, and timeline

Project Structure

autonoma/
├── backend/                  # Node.js + Express + Prisma backend
│   ├── src/
│   │   ├── agents/          # AI agent implementations
│   │   │   ├── coord/       # Coordinator agent
│   │   │   ├── analyst/     # Requirements agent
│   │   │   ├── techlead/    # Architecture agent
│   │   │   ├── devteam/     # Development agent
│   │   │   ├── shipper/     # Deployment agent
│   │   │   └── sentry/      # Monitoring agent
│   │   ├── config/          # Configuration
│   │   ├── db/              # Database client
│   │   ├── models/          # TypeScript types
│   │   ├── services/        # Business logic
│   │   ├── routes/          # API endpoints
│   │   └── utils/           # Utilities (LLM client, etc.)
│   └── prisma/              # Database schema
└── frontend/                 # React + TypeScript + TailwindCSS
    └── src/
        ├── components/      # Reusable components
        ├── pages/           # Page components
        ├── api/             # API client helpers
        ├── types/           # TypeScript types
        └── layouts/         # Layout components

Quick Start

Choose your setup method based on your needs:

Option 1: Docker Setup (Recommended for Production)

cd Autonoma/autonoma
cp .env.example .env
# Edit .env with your configuration (see docs/SETUP_GUIDE.md for production checklist)
docker-compose up -d

Access: Frontend (http://localhost) | Backend API (http://localhost:4000)

Option 2: Native Setup (Recommended for Development)

cd Autonoma/autonoma

# Backend
cd backend && npm install
cp .env.example .env  # Edit with your configuration
npx prisma generate && npx prisma migrate dev
npm run dev  # Runs on http://localhost:4000

# Frontend (new terminal)
cd ../frontend && npm install
echo 'VITE_API_BASE_URL=http://localhost:4000' > .env
npm run dev  # Runs on http://localhost:5173

Complete Setup Guide

For comprehensive setup instructions including:

• Pre-setup checklists (security, dependencies, prerequisites)
• Development vs Production differences and best practices
• Docker configuration for both dev and prod environments
• Troubleshooting common issues
• Post-setup verification steps

→ See docs/SETUP_GUIDE.md for the complete setup guide

Additional documentation:

• Docker Deployment Details
• LLM Configuration
• Security Notes
• Phase Tracking
• Testing Guide

Usage

Creating Your First Project

1. Navigate to http://localhost:5173
2. Log in (default credentials will be created on first run)
3. Click "New Project"
4. Follow the wizard:
   • Select or create a client
   • Describe what the client wants
   • Choose platforms and budget tier
5. Review the AI-generated proposal
6. Accept a scope option (MVP/Standard/Extended)
7. View the automatically generated architecture and milestones

Managing Projects

• Dashboard: View all active projects with health metrics
• Project Detail: See milestones, architecture, and metrics
• Proposal Review: Review and accept/revise proposals
• Deployment: Configure deployment settings and generate deployment configurations (Docker Compose files, environment configs, and step-by-step deployment instructions for manual execution)

API Endpoints

Authentication

• POST /api/auth/login - Login
• POST /api/auth/logout - Logout
• GET /api/auth/me - Get current user

Clients

• GET /api/clients - List clients
• POST /api/clients - Create client
• GET /api/clients/:id - Get client

Projects

• GET /api/projects - List projects
• POST /api/projects - Create project (triggers COORD + ANALYST)
• GET /api/projects/:id - Get project detail
• POST /api/projects/:id/recompute-metrics - Recompute SENTRY metrics

Proposals

• GET /api/projects/:projectId/proposals - List proposals
• GET /api/proposals/:proposalId - Get proposal
• POST /api/proposals/:proposalId/accept - Accept proposal (triggers TECHLEAD + DEVTEAM)
• POST /api/proposals/:proposalId/request-revision - Request revision

Milestones

• PATCH /api/milestones/:id - Update milestone status
• GET /api/milestones/:id/detail - Get milestone detail with DEVTEAM summary

Deployment

• GET /api/projects/:projectId/deployment - Get deployment config
• POST /api/projects/:projectId/deployment/preferences - Save deployment preferences
• POST /api/projects/:projectId/deployment/plan - Generate deployment plan (calls SHIPPER)

Dashboard

• GET /api/dashboard/summary - Get dashboard summary with all projects

Development

Database Migrations

cd backend
npx prisma migrate dev --name migration_name

Prisma Studio

View and edit database data:

cd backend
npx prisma studio

Adding New Agents

1. Create agent directory in backend/src/agents/
2. Create agent file with system prompt and functions
3. Import and use in services/routes

Architecture

Project Lifecycle

1. Intake → Operator creates project
2. Scoping → COORD + ANALYST generate structured proposal
3. Proposal → Operator reviews and accepts scope
4. Design → TECHLEAD creates architecture plan
5. Planning → DEVTEAM creates milestones
6. Development → Operator tracks milestone progress
7. Deployment → SHIPPER generates deployment configurations and instructions (manual deployment required)
8. Monitoring → SENTRY tracks health and alerts

Agent Interactions

COORD (orchestrates)
  ├── calls ANALYST (requirements)
  ├── calls TECHLEAD (architecture)
  ├── calls DEVTEAM (milestones)
  ├── calls SHIPPER (deployment)
  └── calls SENTRY (health monitoring)

Configuration

Project Modes

• STARTER Mode (default): Simple, constrained stack (React + Node + PostgreSQL)
• PRO Mode: Advanced patterns allowed (microservices, queues, etc.)

LLM Configuration

Configure per-agent models in .env:

LLM_MODEL_COORD=gpt-4
LLM_MODEL_ANALYST=gpt-4
LLM_MODEL_TECHLEAD=gpt-4
LLM_MODEL_DEVTEAM=gpt-4
LLM_MODEL_SHIPPER=gpt-4
LLM_MODEL_SENTRY=gpt-4

Troubleshooting

LLM Connection Issues

• Verify LLM_API_URL is correct and accessible
• Check LLM_API_KEY is valid
• Ensure firewall allows outbound connections

Database Connection Issues

• Verify PostgreSQL is running
• Check DATABASE_URL format
• Ensure database exists

Agent Errors

• Check backend logs for detailed error messages
• Verify LLM responses are valid JSON
• Adjust agent prompts if needed

Security Notes

• Change JWT_SECRET in production
• Never commit .env files
• Use proper secrets management for production
• Encrypt LLM API keys in database
• Implement rate limiting for production

License

MIT

Support

For issues and questions, please open an issue on GitHub.