Agent Reference

Agents & Workflows

25 customer-facing AI agents organized into 6 capability domains. Each agent follows the RIGOR verification framework and can be orchestrated together into end-to-end workflows.

BUILD

OPERATE

SECURE

GOVERN

OPTIMIZE

EVOLVE

Shared Agents: debug-ai and review-ai

Two agents serve both BUILD and OPERATE with different roles. In BUILD, debug-ai handles development debugging; in OPERATE, it performs production root cause analysis. In BUILD, review-ai does code review and PR gates; in OPERATE, it validates fixes before deployment. Learned patterns in one capability improve performance in the other.

BUILD

BUILD — Software Development Lifecycle

7 agents (includes shared agents)

req-ai

Requirements

Analyzes requirements, creates specifications, generates user stories from natural language descriptions

Role: Requirements analysis

CLI

autonoma req-ai analyze --file ./requirements.md

autonoma req-ai validate --file ./spec.yaml

API Actions

analyzevalidateextract

planner-ai

Planning

Project planning, task breakdown, sprint organization, effort estimation, and dependency identification

Role: Project planning

CLI

autonoma planner-ai plan --file ./requirements.md

autonoma planner-ai estimate --scope ./spec.yaml

API Actions

planestimatedependencies

architect-ai

Architecture

System design, architecture modeling, technology selection, and design pattern recommendations

Role: Architecture design

CLI

autonoma architect-ai design --file ./requirements.md

autonoma architect-ai validate --architecture ./arch.yaml

API Actions

designvalidatediagram

coder-ai

Code Generation

Code generation, feature implementation, refactoring, and multi-language support from specifications

Role: Implementation

CLI

autonoma coder-ai generate --file ./spec.yaml --language typescript

autonoma coder-ai refactor --file ./src/service.ts

API Actions

generaterefactortestdocument

review-ai

Shared

Code Review

Code review, PR quality gates, coding standards enforcement, and security pattern verification

Role: Code review & PR gates

Also serves OPERATE as pre-deploy verification

CLI

autonoma review-ai review --pr 123

autonoma review-ai style --path ./src

API Actions

reviewstylesecuritystatus

tester-ai

Testing

Test generation, quality assurance, coverage analysis, and test suite optimization

Role: Test generation & QA

CLI

autonoma tester-ai run --suite integration

autonoma tester-ai coverage --path ./src

API Actions

runcoverageflakinesshistory

debug-ai

Shared

Debugging

Development debugging, issue resolution, error tracing, and fix suggestions

Role: Development debugging

Also serves OPERATE as production root cause analysis

CLI

autonoma debug-ai analyze --error "Connection timeout"

autonoma debug-ai troubleshoot --service api

API Actions

analyzetroubleshootlogssessions

BUILD Workflow (Orchestrated)

req-ai → planner-ai → architect-ai → coder-ai → review-ai → tester-ai → debug-ai (as needed)

The BUILD workflow follows the software development lifecycle. Requirements are analyzed, planned into tasks, architected, implemented, reviewed, tested, and debugged. Each phase runs through RIGOR verification before handing off to the next agent.

OPERATE

OPERATE — Operations & Incident Management

8 agents (includes shared agents)

deploy-ai

Deployment

Deployment automation, canary releases, blue-green deployments, and rollback management

Role: Deployment automation

CLI

autonoma deploy-ai deploy --env production --strategy canary

autonoma deploy-ai rollback --deployment dep-123

API Actions

deployrollbackprovisionstatus

maintain-ai

Maintenance

Routine maintenance, self-healing operations, dependency updates, and system health management

Role: Self-healing & maintenance

CLI

autonoma maintain-ai health --service api

autonoma maintain-ai maintenance --type scheduled

API Actions

maintenanceincidentmonitor

observe-ai

Observability

Monitoring, metrics collection, alerting, anomaly detection, and CloudWatch integration

Role: Monitoring & alerting

CLI

autonoma observe-ai metrics --service api

autonoma observe-ai alerts --severity critical

API Actions

metricsalertstraceslogs

incident-ai

Incident Response

Incident triage, severity classification, escalation coordination, and postmortem generation

Role: Incident response

CLI

autonoma incident-ai triage --incident INC-456

autonoma incident-ai escalate --incident INC-456

API Actions

listcreatetriageresolveescalaterunbook

debug-ai

Shared

Root Cause Analysis

Production root cause analysis, distributed tracing, and incident diagnosis

Role: Production RCA

Also serves BUILD as development debugging

CLI

autonoma debug-ai analyze --error "Connection timeout"

autonoma debug-ai logs --service api --tail 100

API Actions

analyzetroubleshootlogssessions

review-ai

Shared

Pre-Deploy Verification

Validates fixes and changes before deployment to production, verifies remediation quality

Role: Pre-deploy verification

Also serves BUILD as code review & PR gates

CLI

autonoma review-ai review --pr 456

autonoma review-ai security --path ./src

API Actions

reviewstylesecuritystatus

capacity-ai

Capacity Planning

Capacity forecasting, auto-scaling recommendations, resource optimization, and load planning

Role: Capacity planning & scaling

CLI

autonoma capacity-ai forecast --service api --period 30d

autonoma capacity-ai recommend --cluster production

API Actions

forecastanalyzerecommendautoscalecost-projection

backup-ai

Backup & Recovery

Backup management, disaster recovery planning, snapshot scheduling, and restore verification

Role: Backup & disaster recovery

CLI

autonoma backup-ai create --target database

autonoma backup-ai verify --backup bak-789

API Actions

createrestoreverifyscheduledr-test

OPERATE Workflow (Orchestrated)

observe-ai (detect) → debug-ai (diagnose) → incident-ai (coordinate) → maintain-ai (fix) → review-ai (verify) → deploy-ai (ship)
capacity-ai + backup-ai run as continuous background operations

The OPERATE workflow is event-driven. Observability agents detect issues, diagnosis agents find root causes, incident response coordinates remediation, maintenance agents apply fixes, review verifies quality, and deployment ships the fix. Capacity planning and backup operations run continuously in the background.

SECURE

SECURE — Security Scanning & Threat Detection

2 agents

security-ai

Security Scanning

Container scanning, dependency analysis, code scanning, secrets detection, IaC validation, and compliance checks

Role: Vulnerability scanning & compliance

CLI

autonoma security-ai scan --path ./project --type all

autonoma security-ai scan --type dependencies --severity critical

API Actions

scancompliancedependenciesvulnerabilities

threathunter-ai

Threat Hunting

Proactive threat hunting, IOC matching, attack path analysis, MITRE ATT&CK mapping, and ML-based anomaly detection

Role: Threat detection & hunting

CLI

autonoma "hunt for threats in infrastructure"

POST /api/workflows/invoke { capability: "SECURE" }

API Actions

huntioc-matchattack-path

SECURE Workflow (Orchestrated)

security-ai (scan & prevent) → threathunter-ai (hunt & detect) → correlate findings

SECURE combines prevention and detection. security-ai focuses on finding vulnerabilities before exploitation (shift-left scanning). threathunter-ai focuses on detecting active threats and attack patterns. Together they provide a complete security lifecycle from prevention to detection.

GOVERN

GOVERN — Compliance & Policy Management

3 agents

govern-ai

Governance

Organization-wide governance audits, compliance framework validation (SOC2, HIPAA, PCI-DSS), and regulatory reporting

Role: Governance & compliance

CLI

autonoma govern-ai audit-trail --scope all

autonoma govern-ai approval --request req-123

API Actions

approvalaudit-trailchangeaccessworkflow

policy-ai

Policy Management

Policy definition, enforcement, validation against deployment configurations, and automated remediation

Role: Policy enforcement

CLI

autonoma policy-ai check --config ./deployment.yaml

autonoma policy-ai enforce --scope production

API Actions

checkenforcereportremediate

tenant-ai

Multi-Tenant Isolation

Tenant provisioning, isolation verification, resource quota management, and cross-tenant security validation

Role: Multi-tenant management

CLI

autonoma tenant-ai check-isolation --tenant acme-corp

autonoma tenant-ai quotas --tenant acme-corp

API Actions

check-isolationquotasliststatus

GOVERN Workflow (Orchestrated)

govern-ai (audit) → policy-ai (enforce) → tenant-ai (isolate)

GOVERN ensures organizational compliance. Governance agents audit against frameworks, policy agents enforce rules on configurations and deployments, and tenant agents manage multi-tenant isolation boundaries.

OPTIMIZE

OPTIMIZE — Performance & Cost Optimization

4 agents

optimize-ai

Performance

Performance analysis, bottleneck identification, latency optimization, and throughput recommendations

Role: Performance optimization

CLI

autonoma optimize-ai analyze --target ./api

autonoma optimize-ai benchmark --endpoint /api/users

API Actions

analyzebenchmarkrecommend

cost-ai

Cost Management

Cloud cost analysis, rightsizing recommendations, reserved instance planning, and waste identification

Role: Cost optimization

CLI

autonoma cost-ai report --period 30d

autonoma cost-ai optimize --scope compute

API Actions

reportforecastoptimizerightsizebudgetsanomalies

dba-ai

Database Administration

Database performance analysis, query optimization, index recommendations, and schema tuning

Role: Database optimization

CLI

autonoma dba-ai analyze-queries --database production

autonoma dba-ai indexes --database production

API Actions

analyze-queriesindexesoptimizeschema

billing-ai

Billing & Metering

Usage metering, billing report generation, customer billing management, and forecast modeling

Role: Billing & metering

CLI

autonoma billing-ai usage --period 30d

autonoma billing-ai analytics --scope all

API Actions

usageinvoicesubscriptionanalytics

OPTIMIZE Workflow (Orchestrated)

optimize-ai (analyze) → cost-ai (reduce spend) → dba-ai (tune queries) → billing-ai (report)

OPTIMIZE agents work together to improve efficiency. Performance agents identify bottlenecks, cost agents find savings, DBA agents tune database workloads, and billing agents track and report usage.

EVOLVE

EVOLVE — Learning & Adaptation

3 agents

adapt-ai

Adaptive Learning

Learns from user feedback, adapts agent behavior, improves recommendations based on patterns

Role: Adaptive learning

CLI

autonoma adapt-ai feedback --model coder-ai --rating good

autonoma adapt-ai evaluate --model coder-ai

API Actions

trainevaluatefeedbackmodelsdeploy

evolve-ai

System Evolution

Analyzes system maturity, recommends architectural improvements, and tracks evolution metrics

Role: System evolution

CLI

autonoma evolve-ai assess --scope architecture

autonoma evolve-ai plan --target microservices

API Actions

assessplanmigraterefactordependencies

success-ai

Customer Success

Customer health scoring, proactive recommendations, onboarding optimization, and retention analysis

Role: Customer success

CLI

autonoma success-ai health --customer acme-corp

autonoma success-ai engagement --period 30d

API Actions

churnengagementonboarding

EVOLVE Workflow (Orchestrated)

adapt-ai (learn from feedback) → evolve-ai (recommend improvements) → success-ai (track outcomes)

EVOLVE agents continuously improve the platform. Adaptive learning incorporates user feedback, evolution agents recommend system improvements, and customer success agents ensure teams are getting maximum value.

PLATFORM ONLY

Cross-Capability Workflows

Cross-capability workflows are goal-driven with defined workflow templates as the starting constraint. Each workflow type has a deterministic agent pipeline that ensures consistent RIGOR execution. The orchestrator holds the stated objective, follows the workflow template, and applies RIGOR verification at every phase — while adapting execution order within the template based on agent load and learned patterns.

Workflow-Constrained Goal Orchestration

Every cross-capability workflow starts from a defined template — a deterministic agent pipeline with known capabilities and RIGOR gates. This ensures consistency and rigor. The orchestrator is goal-aware within that workflow constraint, not free-form reasoning about which agents to involve.

1. Workflow Template

Each workflow type maps to a defined agent pipeline and execution pattern (sequential, parallel, hierarchical). This is the deterministic starting point — not negotiable.

2. Goal Awareness

The orchestrator holds the stated objective through execution. Each agent in the pipeline receives the goal context, not just its isolated input. On failure, the orchestrator retries or escalates within the workflow — not by inventing a new plan.

3. Learned Optimization

Q-Learning from execution outcomes improves how the workflow executes (parallelization, load balancing, timeout tuning) — not which agents are involved. The workflow template is the constraint; optimization happens within it.

Full SDLC

BUILD → SECURE → OPERATE

PLATFORM bundle

End-to-end software delivery: requirements through deployment with security validation

Impact: Eliminates 4-5 day PR cycle time by automating handoffs between code, security, and deployment

Agent Pipeline

req-ai → planner-ai → architect-ai → coder-ai → tester-ai → review-ai → security-ai → deploy-ai → observe-ai

Incident Response

OPERATE → BUILD → SECURE

PLATFORM bundle

Detect issue in production, diagnose root cause, implement fix, validate security, deploy hotfix. Median MTTR drops from days to under 30 minutes.

Impact: 70-80% MTTR reduction. Average incident involves 5-7 people across 3+ teams — agents eliminate manual context assembly.

Agent Pipeline

observe-ai → incident-ai → debug-ai → coder-ai → tester-ai → review-ai → security-ai → deploy-ai

Security-Driven Refactoring

SECURE → BUILD → OPERATE

PLATFORM bundle

Vulnerability discovered, code remediated, tested, and safely deployed. Average vulnerability takes 60-90 days to remediate manually — agents reduce this to hours.

Impact: Eliminates 1-5 day security review queue. 86% of codebases have vulnerable dependencies.

Agent Pipeline

security-ai → threathunter-ai → coder-ai → tester-ai → review-ai → deploy-ai

Dependency Update Cascade

SECURE → BUILD → OPERATE

PLATFORM bundle

Prioritize CVEs, assess architecture impact, update dependencies with compatibility fixes, test, and deploy via canary.

Impact: 70% of dependency vulnerabilities processed automatically. Saves ~7,500 dev-hours/year for a 100-dev team.

Agent Pipeline

security-ai → architect-ai → coder-ai → tester-ai → review-ai → deploy-ai

Compliance Audit Automation

GOVERN → SECURE → OPERATE

PLATFORM + GOVERN

Continuous compliance evidence collection across security posture, monitoring SLAs, backup verification, and tenant isolation — eliminates weeks of manual audit prep.

Impact: Reduces audit prep from 4-12 weeks to days. Saves 200-500 engineering hours per audit cycle.

Agent Pipeline

govern-ai → security-ai → policy-ai → observe-ai → backup-ai → tenant-ai → review-ai

Cost Anomaly Remediation

OPTIMIZE → OPERATE → BUILD

PLATFORM + OPTIMIZE

Detect cloud cost spikes, correlate with deployments, right-size resources, implement infrastructure changes, and track savings.

Impact: ~27% of cloud spend is waste. Reduces anomaly-to-fix from weeks to hours.

Agent Pipeline

cost-ai → observe-ai → capacity-ai → optimize-ai → coder-ai → deploy-ai → billing-ai

Performance Regression Fix

OPERATE → OPTIMIZE → BUILD

PLATFORM + OPTIMIZE

Detect performance regression, bisect deployments, profile code, optimize queries, implement fix, and validate.

Impact: Reduces detection-to-fix from days to hours. Prevents production impact via early CI detection.

Agent Pipeline

observe-ai → debug-ai → optimize-ai → dba-ai → coder-ai → tester-ai → deploy-ai

Technical Debt Prioritization

EVOLVE → OPTIMIZE → BUILD

PLATFORM + EVOLVE + OPTIMIZE

Continuously analyze codebase evolution, measure performance impact, prioritize debt by ROI, and generate refactoring plans.

Impact: Developers spend 13.5 hrs/week on tech debt. Data-driven prioritization can reduce this by 40-60%.

Agent Pipeline

evolve-ai → optimize-ai → security-ai → architect-ai → planner-ai → coder-ai → tester-ai

Threat-to-Incident Correlation

SECURE → OPERATE

PLATFORM bundle

Proactive threat detection triggers incident response workflow

Impact: Eliminates manual handoff between security and operations teams.

Agent Pipeline

threathunter-ai → incident-ai → observe-ai → debug-ai

INVOCATION GUIDE

Invoking Workflows & Tracking Progress

Three ways to invoke agent workflows: natural language, CLI commands, or the REST API. All methods support real-time progress tracking via Server-Sent Events.

Natural Language

Describe what you want — the orchestrator selects the right agents automatically.

# The CLI routes to the right agents
autonoma "review my staged changes for security"
autonoma "deploy to production with canary"
autonoma "analyze slow database queries"

# Watch real-time RIGOR progress
autonoma "refactor auth service" --watch

CLI Commands

Invoke specific agents directly for precise control over which agent handles your request.

# Direct agent invocation
autonoma security-ai scan --path ./src
autonoma tester-ai coverage --path ./src
autonoma deploy-ai deploy --env prod

# Orchestrated multi-agent workflow
autonoma orchestrator-ai execute \
  --workflow full-sdlc \
  --input '{"prompt":"Add auth"}'

REST API

Programmatic access for CI/CD, dashboards, and custom integrations.

# Invoke a workflow
POST /api/workflows/invoke
{
  "capability": "BUILD",
  "workflow": "generate-code",
  "input": {
    "prompt": "Add OAuth2 auth",
    "scope": "mvp"
  }
}
# → 202 { workflowId, statusUrl }

# Check status
GET /api/workflows/{id}/status
# → { status, phases, output }

Real-Time Progress Tracking

Every workflow execution streams RIGOR phase progress in real-time via Server-Sent Events (SSE). The CLI, Dashboard, and VS Code extension all connect to the same event stream.

CLI (--watch flag)

$ autonoma orchestrator-ai execute \
    --task "review security" --watch

 RIGOR Progress: review-ai
 ━━━━━━━━━━━━━━━━━━━━━━━━━━

  Research    ✅ Completed  92%  3.2s
  Inspect     ⏳ Running    —    —
  Generate    ⬜ Pending    —    —
  Optimize    ⬜ Pending    —    —
  Review      ⬜ Pending    —    —

SSE Event Stream (API)

GET /api/admin/events/stream
  ?execution_id=exec-abc123

# Stream response:
event: phase_started
data: {"phase":"Research",
       "agent_id":"review-ai"}

event: work_progress
data: {"phase":"Research",
       "progress":92,
       "confidence":0.92}

event: phase_completed
data: {"phase":"Research",
       "duration_ms":3200}

Dashboard

Live RIGOR phase progress bar with confidence scores

CLI

Animated terminal progress via --watch flag

VS Code

Agent Orchestration sidebar with tree view

GitHub PR

Auto-updating progress comment on pull requests

Endpoint	Method	Purpose	Auth
/api/workflows/invoke	POST	Invoke a capability workflow	API Key
/api/workflows/{id}/status	GET	Check workflow execution status	API Key
/api/workflows	GET	List workflow executions	API Key
/api/workflows/cancel/{id}	POST	Cancel a running workflow	API Key
/api/agents/tasks	POST	Submit a development task	API Key
/api/agents/tasks/{taskId}	GET	Check task status and progress	API Key
/api/agents/{id}/{action}	POST/GET	Direct agent action invocation	Session

Orchestration Architecture

Tier 1: Capability Orchestrator

Each capability domain has its own orchestrator that executes workflows using defined agent pipelines. The orchestrator holds the goal context and applies RIGOR verification at every phase.

Deterministic workflow templates define which agents execute
Goal-aware: passes objective context to each agent in the pipeline
RIGOR phases enforce quality gates at every step
Q-Learning optimizes execution within the template (parallelization, timeouts)
ACMF mode enforcement with auto-regression on failure

Available in: BUILD, OPERATE, SECURE, GOVERN, OPTIMIZE, EVOLVE

Tier 2: Meta-Orchestrator

Coordinates cross-domain workflows using defined templates that specify which capabilities and agents participate. Ensures consistent RIGOR execution across domain boundaries.

Cross-capability workflow templates (e.g., Full SDLC, Incident Response)
GoalDispatcher routes to template-defined agents via deterministic mapping
5 execution patterns: sequential, parallel, hierarchical, group chat, debate
Cross-agent knowledge graph for shared learning within templates
V2 MARL optimization (planned) — multi-agent reinforcement learning for execution tuning
V3 RAFT consensus (planned) — distributed decision-making across orchestrator replicas
Meta-selector routing (planned) — automatic version selection based on task characteristics

Available in: PLATFORM bundle only

Orchestration patterns deep-dive

Deterministic Templates. Elastic Execution.

Workflow templates are the what. The orchestrator's elasticity determines the how. RIGOR ensures the quality.

Think of it like a CI/CD pipeline: the pipeline definition is fixed — you don't want your deploy pipeline randomly deciding to skip testing. But execution is adaptive — steps parallelize when possible, retry on failure, scale runners up and down, and each step receives context-aware inputs.

What's Fixed

Which agents participate — defined by the workflow template, not negotiable
Quality gates — RIGOR phases execute for every step, no shortcuts
Goal-type routing — deterministic mapping from workflow type to agent pipeline

What's Elastic (V1 active; V2/V3 planned)

Execution pattern — 5 patterns (sequential, parallel, hierarchical, group chat, debate) selected per workflow
Parallelization — RIGOR Optimize phase identifies steps that can run concurrently within the template
Load-aware scheduling — overloaded agents (>85% load) trigger backpressure, queueing, or timeout adjustment
Fallback & retry — progressive timeouts, exponential backoff, circuit breakers — transient failures don't kill the workflow
Agent auto-scaling — agents scale to zero when idle and wake on demand, elastic to actual workload
Context enrichment — same template produces different inputs based on project knowledge graph, so execution adapts to your codebase
MARL optimization (V2, planned) — cooperative Q-learning tunes agent selection and scheduling within templates
RAFT consensus (V3, planned) — distributed orchestrator replicas achieve consensus on critical decisions

How elasticity works at runtime

1. Template selected → Full SDLC pipeline: req-ai → planner-ai → architect-ai → coder-ai → review-ai → tester-ai
2. RIGOR Research → Evaluates hypotheses: sequential (0.65) vs parallel (0.88) vs conditional (0.72)
3. RIGOR Inspect → Checks agent load: architect-ai at 92% → flags for backpressure
4. RIGOR Optimize → Detects req-ai and planner-ai have no data dependency → parallelizes them
5. Knowledge enrichment → Injects project context (tech stack, past failures, codebase patterns) into each agent payload
6. Execution → Same template, different execution profile every time — optimized for current conditions

Every Agent Follows RIGOR

All 25 customer-facing agents execute tasks through the 5-phase RIGOR verification framework. No agent takes action without completing Research, Inspect, Generate, Optimize, and Review phases.

Research

Gather context, validate assumptions, identify constraints

Inspect

Audit safety, verify constraints, check preconditions

Generate

Execute task, produce artifact with confidence scoring

Optimize

Tune performance, minimize cost, apply learnings

Review

Validate outcome, run quality gates, prepare rollback

RIGOR framework deep-dive

CONTINUOUS IMPROVEMENT

RIGOR Optimize & Review Feedback Loop

The Optimize and Review phases of RIGOR are not just execution gates — they are a continuous feedback loop that improves every subsequent workflow execution. Patterns discovered by one agent improve all agents across the fleet.

Optimize Phase (Learning)

After generating output, agents analyze their own performance and publish patterns to the shared knowledge graph.

Pattern detection: Agents publish learned patterns to learning.pattern.detected NATS topic
Cross-agent learning: All agents subscribe to patterns from other agents — a security pattern discovered by security-ai improves coder-ai's code generation
Quality scoring: Each agent publishes quality metrics to agent-specific scoring topics for ACMF progression tracking
Performance tuning: Execution time, confidence scores, and resource usage feed back into routing decisions

Review Phase (Validation)

Multi-dimensional quality gates validate output and trigger automatic workflow improvements on failure.

Gate results: 21 quality gates across safety, correctness, performance, and compliance dimensions
ACMF regression: Failed reviews automatically regress agents to lower autonomy levels, requiring human approval for subsequent executions
Workflow refinement: Repeated failures in specific workflow steps trigger orchestrator re-routing — e.g., adding a security scan before deployment if security-ai finds recurring issues
Audit trail: Every gate result is recorded for compliance and postmortem analysis

How the Feedback Loop Works

Execution N                        Execution N+1
┌──────────┐                       ┌──────────┐
│ Research  │                       │ Research  │ ← uses patterns from N
│ Inspect   │                       │ Inspect   │ ← stricter if N failed gates
│ Generate  │                       │ Generate  │ ← applies learned optimizations
│ Optimize  │──→ Knowledge Graph ──→│ Optimize  │ ← builds on prior patterns
│ Review    │──→ ACMF Scores    ──→│ Review    │ ← adjusted gate thresholds
└──────────┘    Quality Metrics     └──────────┘
     │                                    │
     └──→ learning.pattern.detected ──────┘
     └──→ agent.{id}.quality.score ───────┘

Products

Autonoma agents are available as separate capability products on AWS Marketplace.

Core Products

Product	Agents	Description
BUILD	7 agents (5 core + 2 shared): req-ai, planner-ai, architect-ai, coder-ai, review-ai, tester-ai, debug-ai	Software development lifecycle — requirements through code review
OPERATE	8 agents (6 core + 2 shared): deploy-ai, maintain-ai, observe-ai, incident-ai, debug-ai, review-ai, capacity-ai, backup-ai	Operations and incident management — deployment through disaster recovery
SECURE	2 agents: security-ai, threathunter-ai	Security scanning and threat detection
PLATFORM	15 unique agents (BUILD + OPERATE + SECURE combined)	Full SDLC with cross-capability orchestration via MetaOrchestrator

Additional Capability Products

These are separate products that can be added to any core product subscription.

Product	Agents	Description
GOVERN	3 agents: govern-ai, policy-ai, tenant-ai	Compliance, policy management, and multi-tenant isolation
OPTIMIZE	4 agents: optimize-ai, cost-ai, dba-ai, billing-ai	Performance, cost, and database optimization
EVOLVE	3 agents: adapt-ai, evolve-ai, success-ai	Adaptive learning, system evolution, and customer success

Intelligence Tiers

Intelligence tiers control efficiency and security tooling within each product. They are orthogonal to which products you subscribe to — a BUILD customer on Core intelligence uses different security tools than a BUILD customer on Ultra intelligence.

Tier	Efficiency	Security Tools
CORE	Standard efficiency	Trivy container scanning, basic threat hunting
PRO	30% more efficient	+ Snyk dependency scanning, advanced threat queries
ULTRA	50% more efficient	+ SAST code analysis, custom rules, attack path analysis

IDE Integrations

Autonoma Code integrates with traditional IDEs — the editors where your team already works. All integrations connect to the same SSE event stream for real-time agent and RIGOR progress visibility.

VS Code

Available

Agent orchestration sidebar, inline RIGOR progress, deployment readiness checks.

code --install-extension autonoma.autonoma-cloud-environment

JetBrains

Planned

Single plugin for IntelliJ, WebStorm, GoLand, PyCharm. Tool Window for agent status, editor annotations, SSE streaming.

Covers 25-32% of enterprise developers

GitHub Codespaces

Compatible

VS Code extension works in Codespaces. Pre-configured via devcontainer.json for zero-friction onboarding.

Zero setup — open and go

Neovim

Planned

Lua plugin via built-in LSP client. Connects to Autonoma LSP service for code intelligence and agent invocation.

Leverages existing LSP service on port 9000

Autonoma Code vs. AI-Native Editors

Autonoma Code is not a competitor to Cursor, Windsurf, or other AI-native editors. Those tools provide inline code completions and single-model chat within a forked editor. Autonoma Code is a governed autonomous SDLC platform — 25 specialized agents orchestrating your entire software lifecycle from requirements through production monitoring, with enterprise governance, audit trails, and progressive autonomy. Autonoma Code integrates with the IDEs your team already uses, not proprietary editor forks.

All IDEs can also use the CLI (autonoma) for agent invocation and the REST API for custom integrations.

Explore Further

Orchestration Patterns RIGOR Framework ACMF Maturity Model CLI Documentation