Getting Started

Getting Started with Best Practices

Set up Autonoma for maximum value—whether you prefer terminal, IDE, or web workflows. Configure integrations, import historical context, and optimize agent behavior from day one.

1. Choose Your Workflow

Autonoma adapts to how you work. Select your preferred interaction style:

Terminal-First

Command-line developers who prefer shell scripts and automation

RECOMMENDED:

CLIAPI

Install CLI globally, configure shell aliases, use RIGOR commands

IDE-Based

Developers using VS Code, IntelliJ, or similar environments

RECOMMENDED:

SDKDashboard

Integrate SDK into project, use dashboard for monitoring

Web Dashboard

Teams preferring visual interfaces and point-and-click workflows

RECOMMENDED:

DashboardAPI

Use dashboard for all operations, API for custom integrations

2. Set Up Access Methods

Get your tools configured for immediate productivity:

Command Line Interface

Full RIGOR framework access from your terminal

# Install globally
npm install -g @autonoma-io/code

# Authenticate
autonoma auth login

# Initialize in your project
autonoma init

# Run RIGOR analysis
autonoma rigor analyze --phase research

# Sample commands
autonoma agents list
autonoma workflow create --name "deploy-staging"
autonoma status

Full CLI Documentation

SDK Integration

Embed Autonoma directly in your application code

// TypeScript/JavaScript
import { Autonoma } from '@autonoma/sdk';

const autonoma = new Autonoma({
  apiKey: process.env.AUTONOMA_API_KEY,
  projectId: 'my-project',
  acmfMode: 'ASSISTED', // Start in assisted mode
});

// Enable autonomous operations
await autonoma.start();
await autonoma.trackPerformance();

// Invoke specific agent
const result = await autonoma.invoke('architect-ai', {
  task: 'design-microservice',
  context: { requirements: '...' }
});

SDK Reference

Web Dashboard

Visual interface for monitoring, configuration, and approvals

Real-time agent activity monitoring

ACMF mode management per agent

Human approval workflows

RIGOR execution history and audit logs

Open Dashboard

REST API

Direct API access for custom integrations and automation

# Invoke RIGOR agent
curl -X POST 'https://api.theautonoma.io/api/v1/rigor/invoke/coder-ai' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "prompt": "Generate unit tests for auth module",
    "priority": "normal",
    "acmfMode": "ASSISTED"
  }'

# Check execution status
curl 'https://api.theautonoma.io/api/v1/rigor/status/exec-123' \
  -H 'Authorization: Bearer YOUR_API_KEY'

API Reference

3. Connect Third-Party Integrations

Import historical project context and enable real-time synchronization with your existing tools:

AWS CloudWatch

Monitoring

~10 min setup

Sync metrics, logs, and alarms for unified observability

Metrics ingestionLog aggregationAlarm triggersDashboard sync

PagerDuty

Incident Management

~5 min setup

Route alerts, manage on-call schedules, automate escalations

Event routingIncident triggersEscalation policiesResolution tracking

Datadog

APM & Monitoring

~10 min setup

Full-stack observability with APM, logs, and infrastructure metrics

APM tracesCustom metricsLog forwardingDashboard integration

Jira

Project Management

~15 min setup

Sync issues, automate workflows, connect development to planning

Webhook eventsIssue creationStatus syncSprint integration

Slack

Native

Communication

~5 min setup

Native integration for alerts, approvals, and team notifications

Alert notificationsApproval workflowsAgent commandsStatus updates

AWS CloudWatch Integration

Configuration

# autonoma.config.yaml
integrations:
  cloudwatch:
    enabled: true
    region: us-east-1
    credentials:
      access_key_id: ${AWS_ACCESS_KEY_ID}
      secret_access_key: ${AWS_SECRET_ACCESS_KEY}

    # Metrics to sync
    metrics:
      namespaces:
        - AWS/ECS
        - AWS/RDS
        - Custom/Autonoma
      period: 60  # seconds

    # Log groups to ingest
    logs:
      groups:
        - /aws/ecs/autonoma-alpha
        - /aws/lambda/autonoma-*

    # Alarm integration
    alarms:
      sync_existing: true
      create_autonoma_alarms: true
      sns_topic_arn: arn:aws:sns:us-east-1:xxx:alerts

Best Practices

• Use CloudWatch Embedded Metric Format for high-cardinality data
• Enable detailed monitoring (1-min intervals) for critical resources
• Create composite alarms to reduce alert fatigue
• Use Anomaly Detection for dynamic thresholds
• Tag resources consistently for filtering

AWS CloudWatch Best Practices

PagerDuty Integration

Events API v2 Configuration

# autonoma.config.yaml
integrations:
  pagerduty:
    enabled: true
    # Get routing key from PagerDuty service integration
    routing_key: ${PAGERDUTY_ROUTING_KEY}

    # Event routing rules
    routing:
      critical:
        severity: critical
        class: infrastructure
      warning:
        severity: warning
        class: application

    # Dedup key strategy
    dedup_strategy: deployment_id  # or: alert_type, custom

    # Webhook for bi-directional sync (V3)
    webhooks:
      enabled: true
      endpoint: https://api.theautonoma.io/webhooks/pagerduty
      events:
        - incident.triggered
        - incident.acknowledged
        - incident.resolved

Security Notes

• Store routing key in environment variables, never in code
• Use V3 webhooks (V2 is end-of-support)
• Verify webhook signatures using X-PagerDuty-Signature header
• Use dedup_key to prevent duplicate incidents

PagerDuty Events API v2 Docs

Datadog Integration

Configuration

# autonoma.config.yaml
integrations:
  datadog:
    enabled: true
    api_key: ${DD_API_KEY}
    app_key: ${DD_APP_KEY}
    site: datadoghq.com  # or datadoghq.eu

    # Metrics submission
    metrics:
      enabled: true
      prefix: autonoma
      tags:
        - env:production
        - service:autonoma

    # APM trace correlation
    apm:
      enabled: true
      service_name: autonoma-agents

    # Log forwarding
    logs:
      enabled: true
      source: autonoma
      service: autonoma-rigor

    # Events (deployments, incidents)
    events:
      enabled: true
      aggregation_key: autonoma_deployment

OpenTelemetry Support

Autonoma supports OTel for vendor-agnostic telemetry:

OTEL_EXPORTER_OTLP_ENDPOINT=https://api.datadoghq.com
OTEL_EXPORTER_OTLP_HEADERS=DD-API-KEY=${DD_API_KEY}

Datadog API Reference

Jira Integration

Webhook + REST API Configuration

# autonoma.config.yaml
integrations:
  jira:
    enabled: true
    base_url: https://yourcompany.atlassian.net

    # Authentication (use API token, not password)
    auth:
      email: ${JIRA_EMAIL}
      api_token: ${JIRA_API_TOKEN}

    # Project mapping
    projects:
      default: PROJ
      mapping:
        infrastructure: INFRA
        security: SEC

    # Webhook events to receive
    webhooks:
      endpoint: https://api.theautonoma.io/webhooks/jira
      events:
        - jira:issue_created
        - jira:issue_updated
        - jira:sprint_started
        - jira:sprint_closed

    # Issue creation templates
    templates:
      bug:
        project: PROJ
        issuetype: Bug
        priority: Medium
      task:
        project: PROJ
        issuetype: Task

GitHub + Jira Automation

Connect GitHub PRs to Jira issues automatically:

Create Automation rule with "Incoming webhook" trigger
Configure GitHub webhook for Pull Request events
Use Smart Values to extract PR data
Auto-transition issues based on PR status

Jira Webhooks REST API v3

Slack (Native Integration)

Autonoma includes native Slack integration with no additional configuration required.

# Simply enable in your dashboard or config
integrations:
  slack:
    enabled: true
    # OAuth installed via dashboard - one-click setup

    channels:
      alerts: "#autonoma-alerts"
      approvals: "#autonoma-approvals"
      deployments: "#deployments"

    notifications:
      - type: deployment_started
        channel: deployments
      - type: approval_required
        channel: approvals
        mention: "@oncall"
      - type: alert_critical
        channel: alerts
        mention: "@here"

Connect Slack in Dashboard

4. Configure Agent Behavior (ACMF)

Set the appropriate autonomy level for each agent based on your risk tolerance:

Mode	Behavior	Risk Level	Recommended Use Case
OBSERVE	Observe only, no execution	None	Initial deployment, learning phase
LEARNING	Execute with full review	Low	Building confidence, pattern recognition
ASSISTED	Execute, approve critical only	Medium	Normal operations
AUTONOMOUS	Full autonomy, audit trail	Managed	Trusted, mature agents

Sample ACMF Configuration

# autonoma.config.yaml
agents:
  # Start observability agents in AUTONOMOUS mode
  observe-ai:
    acmf_mode: AUTONOMOUS
    capabilities: [self-monitoring, self-diagnosing]

  # Code generation in ASSISTED mode (review changes)
  coder-ai:
    acmf_mode: ASSISTED
    capabilities: [self-coding, self-testing]
    approval_required_for:
      - production_changes
      - security_sensitive

  # Deploy in LEARNING mode initially
  deploy-ai:
    acmf_mode: LEARNING
    capabilities: [self-deploying]
    progression:
      to_assisted:
        success_rate: 0.95
        min_tasks: 50
        consecutive_success: 10

Learn more about ACMF Maturity Model

5. Quick Reference: Sample Commands

Common commands to get started immediately:

RIGOR Workflow Commands

# Research phase - gather context
autonoma rigor research "implement user auth"

# Inspect phase - validate constraints
autonoma rigor inspect --project ./

# Generate phase - create implementation
autonoma rigor generate --task "add JWT auth"

# Optimize phase - improve performance
autonoma rigor optimize --target latency

# Review phase - validate outcome
autonoma rigor review --execution exec-123

Agent & Workflow Commands

# List available agents
autonoma agents list

# Invoke specific agent
autonoma invoke architect-ai "design payment service"

# Create deployment workflow
autonoma workflow create deploy-staging \
  --trigger git-push \
  --branch staging

# Check system health
autonoma health

# View audit logs
autonoma logs --agent deploy-ai --last 1h

Ready to Go Further?

Explore Architecture RIGOR Framework Open Dashboard