🤖 ADA — Autonomous Dev Agents

Ship software with autonomous AI dev teams.

ADA lets you set up a team of AI agents that autonomously manage your software project — from strategy and research to product specs, engineering, ops, and design. Each agent has a specialized role, a playbook, and a shared memory bank for continuity.

🎯 Multi-role agent teams — Not just a code bot. A CEO, researcher, PM, engineer, ops lead, and designer working in rotation.
🔄 Autonomous dispatch loop — Heartbeat-driven cycles where each role reads context, acts, and updates shared memory.
🧠 Persistent memory — A shared memory bank gives agents continuity across sessions, with automatic compression and archiving.

Quick Start

# Install the CLI
npm install -g @ada-ai/cli

# Initialize agent team in your repo
cd my-project
ada init

# Run one dispatch cycle
ada run

# Check team status
ada status

How It Works

┌──────────────────────────────────────────────┐
│              Heartbeat Trigger                │
│         (every N minutes via cron/CI)         │
└──────────────┬───────────────────────────────┘
               │
               ▼
┌──────────────────────────────────────────────┐
│           ADA Dispatch Protocol               │
│                                               │
│  1. Load rotation state → who am I?           │
│  2. Read memory bank → what's happening?      │
│  3. Read my playbook → what can I do?         │
│  4. Check GitHub (issues, PRs) → what's new?  │
│  5. Pick & execute ONE action                 │
│  6. Update memory bank                        │
│  7. Advance rotation → next role              │
│  8. Commit & push                             │
└──────────────────────────────────────────────┘

Each cycle, the agent becomes one role. After acting, it rotates to the next. Over a full rotation, every aspect of your project gets attention:

Cycle	Role	What It Does
0	👔 CEO	Sets strategy, analyzes market, defines direction
1	🔬 Research	Scouts technologies, evaluates feasibility
2	📦 Product	Writes specs, creates feature issues, prioritizes
3	📋 Scrum	Plans sprints, tracks progress, unblocks
4	⚙️ Engineering	Writes code, creates PRs, reviews
5	🛡️ Ops	Merges PRs, fixes CI, enforces standards
6	🎨 Design	Reviews APIs, proposes architecture

Features

CLI (`@ada-ai/cli`)

ada init — Bootstrap agent team with interactive setup
ada run — Execute one dispatch cycle (or --watch for continuous)
ada status — See rotation state, team info, memory summary
ada config — View and edit team configuration

Core Library (`@ada-ai/core`)

TypeScript types for roles, rosters, rotation, and memory
Rotation state machine with history tracking
Memory bank read/write/compress/archive
Dispatch protocol orchestration

Templates

Pre-configured agent teams for different project types
Customizable playbooks, roster, and rules
Extensible — add your own roles and actions

Web Dashboard (coming soon)

Real-time cycle monitoring
Memory bank viewer with search
Role configuration UI
Metrics and analytics

Executor Backends

ADA supports multiple AI executor backends. By default, ADA uses Clawdbot, but you can switch to Claude Code or OpenAI Codex for agent execution.

Supported Executors

Executor	Command	Install
Clawdbot (default)	`clawdbot agent --local`	Built-in
Claude Code	`claude-code run`	`npm install -g @anthropic-ai/claude-code`
Codex	`codex execute`	`npm install -g @openai/codex-cli`

Configuration

# Per-cycle: use --executor flag
ada dispatch start --executor claude-code
ada dispatch start --executor codex

# Persistent: set environment variable
export ADA_EXECUTOR=claude-code
ada dispatch start

Priority order: CLI flag --executor > ADA_EXECUTOR env var > clawdbot default.

Environment Variables

Variable	Default	Options	Description
`ADA_EXECUTOR`	`clawdbot`	`clawdbot`, `claude-code`, `codex`	Select executor backend

All three executors follow ADA's abstract executor pattern — they are interchangeable at the framework level. Each executor builds a prompt from the dispatch context, executes via its CLI, and parses the response back into ADA's standard ActionResult format.

Cost Optimization

ADA automatically selects the most cost-effective LLM model for each role, saving ~14% compared to using a single model for all operations.

Model	Usage	Roles	Cost
Haiku	35%	Scrum, Evangelist, Ops (routine tasks)	$
Sonnet	62%	Engineering, Product, Research, Design	$$
Opus	3%	CEO (critical decisions only)	$$$

How It Works

When you run ada dispatch start, ADA automatically selects the optimal model based on the current role. No configuration required — it just works.

🚀 Cycle 730 Started

  Role:      🎨 The Architect
  Model:     ⚖️ sonnet (auto)

Power User Overrides

For specific cycles where you need a different model:

# Force Opus for a critical decision
ada dispatch start --model=opus

# Force Haiku for a routine task
ada dispatch start --model=haiku

Or set environment variables for persistent overrides:

Variable	Description
`ADA_MODEL_ROUTING`	Enable/disable auto-routing (default: `true`)
`ADA_MODEL_OVERRIDE`	Force specific model: `haiku`, `sonnet`, or `opus`
`ADA_MODEL_FALLBACK`	Enable fallback escalation on failures (default: `true`)

For deployment configuration, see Railway deployment docs.

Notifications

ADA can send notifications to Slack, Telegram, and Discord when agents complete their cycles. This keeps you informed about agent activity without constantly checking the repository.

Quick Setup

# Configure Slack
ada config notifications set slack <webhook-url>

# Configure Telegram
ada config notifications set telegram <bot-token> <chat-id>

# Configure Discord
ada config notifications set discord <webhook-url>

# Test a notification
ada config notifications test slack
ada config notifications test telegram
ada config notifications test discord

# View current configuration
ada config notifications show

Slack Setup

Go to https://api.slack.com/apps
Click "Create New App" → "From scratch"
Name your app (e.g., "ADA Notifications") and select your workspace
In the app settings, go to "Incoming Webhooks"
Toggle "Activate Incoming Webhooks" to ON
Click "Add New Webhook to Workspace"
Choose the channel where you want notifications
Copy the webhook URL (format: https://hooks.slack.com/services/T.../B.../...)

Configure in ADA:

ada config notifications set slack https://hooks.slack.com/services/T.../B.../...

Telegram Setup

Open Telegram and search for @BotFather
Send /newbot and follow the prompts to create a bot
Copy the bot token (format: 123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11)
Get your chat ID:
- For personal chats: Use @userinfobot — it will show your user ID
- For groups/channels: Add @getidsbot to the group/channel
- Or visit: https://api.telegram.org/bot<YOUR_BOT_TOKEN>/getUpdates and look for chat.id

Configure in ADA:

ada config notifications set telegram <bot-token> <chat-id>

Discord Setup

Open your Discord server
Go to Server Settings → Integrations → Webhooks
Click "New Webhook"
Configure:
- Name (e.g., "ADA Notifications")
- Channel where notifications should be sent
- Optional: Set an avatar
Click "Copy Webhook URL" (format: https://discord.com/api/webhooks/.../...)

Configure in ADA:

ada config notifications set discord https://discord.com/api/webhooks/.../...

Managing Notifications

# Enable all notifications
ada config notifications enable

# Enable a specific channel
ada config notifications enable slack
ada config notifications enable telegram
ada config notifications enable discord

# Disable all notifications
ada config notifications disable

# Disable a specific channel
ada config notifications disable slack

What Gets Notified

When an agent completes a cycle (ada dispatch complete), notifications include:

Cycle number and role (emoji + name)
Commit subject and body (the action description)
Commit SHA and role ID

Each channel formats messages differently:

Slack: Block Kit format with expandable sections
Telegram: Markdown-formatted message
Discord: Rich embed with color coding based on outcome

Security

Notification credentials are stored in agents/config.json. For security:

Add to .gitignore (if not already there):
```
echo "agents/config.json" >> .gitignore
```

Use environment variables (recommended for CI/CD):

{
  "notifications": {
    "channels": {
      "slack": {
        "webhookUrl": "${SLACK_WEBHOOK_URL}"
      },
      "telegram": {
        "botToken": "${TELEGRAM_BOT_TOKEN}",
        "chatId": "${TELEGRAM_CHAT_ID}"
      }
    }
  }
}

The system automatically resolves environment variables in config values.

Dogfooding 🐕

ADA builds itself. This repo has its own agent team in agents/ that runs the ADA dispatch protocol to develop the ADA product. It's the first and most active customer of its own framework.

Case Study: Social Trade

Social Trade is ADA's proof-of-concept customer — a real project where autonomous agents manage the full development lifecycle, from market research to code implementation to CI/CD.

Architecture

autonomous-dev-agents/
├── agents/          ← ADA's own agent team (dogfooding)
├── packages/
│   ├── cli/         ← @ada-ai/cli — the CLI tool
│   └── core/        ← @ada-ai/core — shared library
├── apps/
│   └── web/         ← Marketing site + dashboard (planned)
├── templates/       ← Template files for `ada init`
└── docs/            ← Business, product, research, architecture docs

Pricing

	Free	Pro	Enterprise
CLI tool	✅	✅	✅
All templates	✅	✅	✅
Local execution	✅	✅	✅
Web dashboard	—	✅	✅
Cycle analytics	—	✅	✅
Custom roles	—	—	✅
SSO & team mgmt	—	—	✅
Priority support	—	—	✅
Price	Free	$19/mo	$99/mo

Why Open Source?

Unlike closed-source AI dev tools where learnings stay siloed, ADA's open source model means improvements benefit everyone instantly.

The Problem with Proprietary Agents

With closed-source AI coding tools:

Each company runs isolated instances with no shared learnings
Bug fixes require waiting weeks for vendor releases
You pay for features others have already solved
No cross-pollination of improvements

The ADA Advantage

With ADA's open source model:

Benefit	How It Works
Shared learnings	When one team discovers a better playbook pattern, everyone benefits
Instant propagation	`git pull` and you have the latest improvements
Community-driven evolution	Playbooks, rules, and memory patterns improve collectively
No vendor lock-in	Fork, customize, and contribute back
Compounding returns	More users = faster improvement cycle

Concrete Examples

Playbook improvements — Company A discovers a better QA playbook? They PR it, Company B gets it immediately
Memory compression — Better compression algorithms from power users benefit everyone
Role definitions — New roles like "Security Auditor" can be contributed and adopted across deployments
Bug fixes — Critical fixes propagate instantly vs waiting 6 weeks for a vendor release

The more teams use ADA, the smarter everyone's agents become.

Community

Join the ADA community to discuss autonomous development, get help, and share your experiences:

🎮 Discord Server — Chat with the team, ask questions, share feedback
🐛 GitHub Issues — Report bugs, request features
📢 GitHub Discussions — Longer-form conversations

Contributing

ADA is open source. Contributions welcome!

Fork the repo
Create a feature branch: git checkout -b feat/my-feature
Make your changes (TypeScript strict, tests required)
Run checks: npm run typecheck && npm test
Open a PR targeting main

See agents/rules/RULES.md for coding standards.

Development

# Clone and install
git clone https://github.com/ishan190425/autonomous-dev-agents.git
cd autonomous-dev-agents
npm install

# Type check all packages
npm run typecheck

# Run tests
npm test

# Build all packages
npm run build

# Run CLI in dev mode
npm run dev -- status

License

Open Source (AGPLv3)

ADA's core framework is licensed under GNU Affero General Public License v3.0 (AGPLv3).

This means you're free to:

✅ Use ADA for any purpose, including commercial projects
✅ Modify the source code
✅ Self-host ADA on your own infrastructure
✅ Distribute your modifications

Important: If you modify ADA and offer it as a hosted service (SaaS), you must publish your modifications under AGPLv3. This protects the open source community while allowing commercial use.

Commercial Licensing

The following components are available under a separate commercial license:

Web Dashboard (apps/web) — Real-time monitoring, analytics, and team management UI
Hosted Execution — Cloud-based agent execution services
Enterprise Features — SSO, advanced team management, custom roles, priority support

This dual-licensing model ensures:

🛡️ Protection — Prevents cloud providers from strip-mining ADA without contributing back
🌱 Open Source Credibility — Core framework remains truly open source
💼 Sustainable Business — Enables a viable SaaS + enterprise business model

For commercial licensing inquiries, contact: ishan@rathicapitalventures.com

See LICENSE for full terms.

Built by Rathi Industries — engineering the future with autonomous AI teams.

Name		Name	Last commit message	Last commit date
Latest commit History 1,480 Commits
.ada/reflexion		.ada/reflexion
.github		.github
.husky		.husky
.railway		.railway
agents		agents
apps		apps
docker		docker
docs		docs
packages		packages
templates		templates
.dockerignore		.dockerignore
.gitignore		.gitignore
.prettierrc.json		.prettierrc.json
CHANGELOG.md		CHANGELOG.md
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
CONTRIBUTING.md		CONTRIBUTING.md
Dockerfile		Dockerfile
LICENSE		LICENSE
README.md		README.md
eslint.config.mjs		eslint.config.mjs
lint-staged.config.mjs		lint-staged.config.mjs
package-lock.json		package-lock.json
package.json		package.json
railway.json		railway.json
railway.toml		railway.toml
tsconfig.json		tsconfig.json

Folders and files

Latest commit

History

Repository files navigation

🤖 ADA — Autonomous Dev Agents

Quick Start

How It Works

Features

CLI (@ada-ai/cli)

Core Library (@ada-ai/core)

Templates

Web Dashboard (coming soon)

Executor Backends

Supported Executors

Configuration

Environment Variables

Cost Optimization

How It Works

Power User Overrides

Notifications

Quick Setup

Slack Setup

Telegram Setup

Discord Setup

Managing Notifications

What Gets Notified

Security

Dogfooding 🐕

Case Study: Social Trade

Architecture

Pricing

Why Open Source?

The Problem with Proprietary Agents

The ADA Advantage

Concrete Examples

Community

Contributing

Development

License

Open Source (AGPLv3)

Commercial Licensing

About

Resources

License

Code of conduct

Contributing

Uh oh!

Stars

Watchers

Forks

Releases 1

Packages 0

Uh oh!

Uh oh!

Contributors

Uh oh!

Languages

CLI (`@ada-ai/cli`)

Core Library (`@ada-ai/core`)

Packages