DAA — Debugging
Autonomous Agent

How It Works

DAA runs a fully autonomous pipeline from error detection to pull request — no human in the loop until code review.

4-Dimension Investigation

The AI agent investigates across multiple signal dimensions to build a complete picture:

What Makes DAA Different

Features

Quickstart

Get up and running with DAA in under 60 seconds. Choose your deployment mode:

docker run -d --name daa \
  -p 8000:8080 \
  -e LLM_PROVIDER=google \
  -e GEMINI_API_KEY="your_api_key_here" \
  -e LLM_MODEL="gemini-2.5-flash" \
  -e DAA_DB_PROVIDER=none \
  -e DAA_GIT_TOKEN="github_pat_..." \
  -e GIT_HOST="https://github.com" \
  -e GIT_ORG="your-github-username" \
  rutvej1/daa-standalone:latest

git clone https://github.com/rutvej/DAA.git
cd DAA
cp .env.example .env    # Edit with your credentials
docker compose up -d

curl -sSL https://raw.githubusercontent.com/rutvej/DAA/main/install.sh | bash
daa init      # Interactive setup wizard

curl http://localhost:8000/health
# → {"status": "ok"}

curl -X POST http://localhost:8000/ingest/generic \
  -H "Content-Type: application/json" \
  -d '{
    "title": "ZeroDivisionError in calculator.py:15",
    "stack_trace": "Traceback (most recent call last):\n  File \"calculator.py\", line 15\nZeroDivisionError: division by zero",
    "app_name": "test-app",
    "severity": "critical"
  }'

docker logs -f daa    # Watch in real-time

Architecture

DAA integrates into your existing observability stack. Here's the high-level event pipeline:

┌──────────────┐         ┌──────────────────┐           ┌────────────────┐
│  Production  │  ──►    │   DAA Ingestion   │  ──►     │  Agent Worker  │
│   Service    │ webhook │   (FastAPI)       │  queue   │  (LangChain    │
│              │         │                  │          │   ReAct Agent) │
└──────────────┘         └──────────────────┘           └───────┬────────┘
                                                                │
                                               ┌────────────────▼────────────────┐
                                               │         Tool Executor           │
                                               │  git_log · read_file · grep    │
                                               │  run_tests · write_patch       │
                                               │  create_branch · open_pr       │
                                               └────────────────────────────────┘

Project Structure

DAA/
├── app/
│   ├── backend-api/    ← FastAPI: ingest, dedup, incident tracking
│   ├── python-agent/   ← LangChain ReAct SRE agent (the brain)
│   ├── admin-panel/    ← React dashboard (incidents, apps, config)
│   ├── daa-sdk/        ← Python SDK (+ Node/Go/Java/Ruby/.NET)
│   ├── common/         ← Shared DB, config, queue, fingerprint utils
│   └── daa_mcp_server.py ← MCP server for Claude Desktop / Cursor
├── daa                 ← CLI tool (daa init / register / test / logs)
├── docker-compose.yml  ← Full-stack deployment
├── Dockerfile          ← Single-container build
├── install.sh          ← One-line installer
└── docs/               ← Documentation

Component Status

AI Agent Deep Dive

The SRE agent uses a 3-phase pipeline with a LangChain ReAct loop at its core:

1. Pre-flight: Fingerprint dedup, repo cache, log hydration, context packaging
2. Agent Core: LLM-powered ReAct loop with tool execution (hard budget cap)
3. Post-flight: Parse output, apply diff, create branch/PR, generate postmortem

Agent Tool Inventory

Deduplication Engine

DAA uses SHA-256 fingerprinting to eliminate alert fatigue:

fingerprint = SHA-256( app_name : exception_type : normalized_top_frame )

if fingerprint seen within cooldown window (default 3600s):
    → return 200 "suppressed"
else:
    → create incident
    → enqueue for investigation

Fingerprints are normalized to strip volatile data (hex addresses, timestamps, variable line numbers) ensuring deterministic matching.

Deployment

Full-Stack Docker Compose

For production with persistence, async queue, and admin UI:

git clone https://github.com/rutvej/DAA.git
cd DAA
cp .env.example .env    # Edit with your credentials
docker compose up -d

# Access points:
# API:            http://localhost:8000
# Admin Panel:    http://localhost:5003
# RabbitMQ UI:    http://localhost:15672

Services in Docker Compose

Cloud Deployment

gcloud run deploy daa \
  --image rutvej1/daa-standalone:latest \
  --port 8080 \
  --set-env-vars LLM_PROVIDER=google \
  --set-env-vars GEMINI_API_KEY=your-key \
  --set-env-vars LLM_MODEL=gemini-2.5-flash \
  --set-env-vars DAA_DB_PROVIDER=none \
  --set-env-vars DAA_GIT_TOKEN=your-token \
  --set-env-vars GIT_HOST=https://github.com \
  --set-env-vars GIT_ORG=your-org \
  --allow-unauthenticated

# Use ECS task definition with:
# Image: rutvej1/daa-standalone:latest
# Port: 8080
# Environment variables same as above
# DAA_DB_PROVIDER=none for stateless mode

SDK

Instrument your app with a single line of code. The SDK catches exceptions and sends them to DAA.

# pip install daa-sdk
from daa_sdk import DaaSdk

# Auto-reads DAA_BACKEND_API_URL and DAA_TOKEN from env
daa = DaaSdk()

# Report a caught exception
try:
    risky_operation()
except Exception as e:
    daa.capture_exception(e)

from daa_sdk.integrations import flask_integration

app = Flask(__name__)
daa = DaaSdk()
flask_integration(app, daa)
# All unhandled exceptions now auto-report to DAA

# settings.py
MIDDLEWARE = [
    'daa_sdk.integrations.DjangoDAAMiddleware',
    # ... other middleware
]

from daa_sdk.integrations import fastapi_integration

app = FastAPI()
daa = DaaSdk()
fastapi_integration(app, daa)

SDK Environment Variables

Webhook Integrations

Point your existing alerting tools at DAA — no SDK or code changes required.

# alertmanager.yml
receivers:
  - name: daa
    webhook_configs:
      - url: 'http://your-daa:8000/ingest/prometheus'
        send_resolved: true
        http_config:
          headers:
            X-API-Key: your-api-key

# Sentry Project Settings → Integrations → Webhooks
#
# URL:    http://your-daa:8000/ingest/sentry
# Secret: your-sentry-webhook-secret
# Events: issue.created, event.alert
#
# DAA verifies HMAC-SHA256 signature automatically

# Datadog → Integrations → Webhooks → New Webhook
#
# Name:    DAA
# URL:     http://your-daa:8000/ingest/generic
# Headers: {"X-API-Key": "your-api-key"}
# Payload: {
#   "title": "$EVENT_TITLE",
#   "body": "$EVENT_MSG",
#   "severity": "$ALERT_TYPE"
# }

curl -X POST http://your-daa:8000/ingest/generic \
  -H "Content-Type: application/json" \
  -H "X-API-Key: your-api-key" \
  -d '{
    "title": "Error in payment service",
    "stack_trace": "Traceback (most recent call last)...",
    "app_name": "payment-svc",
    "severity": "critical"
  }'

Supported Sources

MCP Server

Use DAA as a tool inside Claude Desktop, Cursor, or any MCP-compatible AI client.

Available MCP Tools

Claude Desktop Configuration

{
  "mcpServers": {
    "daa": {
      "command": "python",
      "args": ["/path/to/app/daa_mcp_server.py"],
      "env": {
        "DAA_HOST": "http://localhost:8000",
        "DAA_API_KEY": "your-api-key"
      }
    }
  }
}

Git Integration

Supported Forges

Workspace Modes

REST API Reference

Base URL: http://your-daa:8000

Health & Status

Ingestion

Incidents

Fixes

Applications

Alerts

Authentication

Real-time Streaming

CLI Reference

The daa CLI provides complete management of your DAA installation.

Configuration Reference

All configuration is via environment variables. Copy .env.example to .env and customize.

LLM Provider

Database & Queue

Git Integration

Security & Auth

Agent Configuration

Security

Self-hosted and private by design. Your code never leaves your infrastructure (except to the LLM provider you choose).

Security Hardening Checklist

• Set CORS_ALLOW_ORIGINS to your specific domains
• Enable DAA_AUTH_ENABLED=true for SDK endpoints
• Use a strong DAA_API_KEY for webhook endpoints
• Deploy behind a reverse proxy (nginx, Caddy, Traefik)
• Use HTTPS in production
• Restrict Docker network access
• Rotate git tokens regularly

Performance

Roadmap

v3.1 — Next

• Multi-language agent (JavaScript, Go, Java)
• Slack / Teams notifications
• Incident clustering & trend analysis

v3.2

• Kubernetes operator
• Auto-scaling workers
• Fine-tuned models for common error patterns

v4.0 — Vision

• Multi-repo investigation (cross-service root cause)
• Automated rollback integration
• Self-improving agent (learns from merged PRs)

Contributing

PRs welcome! For large changes, open an issue first to align on the approach.

# Development Setup
git clone https://github.com/rutvej/DAA.git
cd DAA
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

# Run tests
python -m pytest test.py -v

# Linting
ruff check .