A6s CLI Documentation

v4.0

Intelligent multi-agent orchestration with 32 specialized AI agents

32 AI Agents

LSP Integration

5 IDE Extensions

Background Agents

Installation

Install via npm

npm install -g @autonoma-io/code

Install via yarn

yarn global add @autonoma-io/code

Install via pnpm

pnpm add -g @autonoma-io/code

Verify installation

a6s --version

What's New in v4.0

Version 4.0 represents a major evolution of Autonoma Code, implementing multi-agent orchestration, enterprise features, and developer productivity improvements.

LSP Integration

Intelligent code navigation with go-to-definition, find references, and call hierarchy for impact analysis.

Background Agents

Long-running tasks that execute asynchronously while you continue working.

5 IDE Extensions

VS Code, JetBrains, Neovim, Emacs, Sublime Text — same protocol, any editor.

32 Specialized Agents

Domain-specific agents for architecture, security, testing, performance, and more.

LSP Integration

Language Server Protocol (LSP) integration provides intelligent code understanding to AI agents, enabling accurate refactoring, impact analysis, and context-aware suggestions.

LSP-Enabled Operations

•

Go to Definition

Navigate to symbol definitions

•

Find References

Find all usages of a symbol

•

Call Hierarchy

Trace function calls for impact analysis

•

Hover Information

Type info and documentation

Supported Languages

Go (gopls)TypeScript/JavaScriptPython (pylsp)Rust (rust-analyzer)

Command	Description
`autonoma lsp symbols <file>`	List all symbols (functions, classes, variables) in a file
`autonoma lsp definition <file> <line> <col>`	Go to the definition of a symbol at position
`autonoma lsp references <file> <line> <col>`	Find all references to a symbol at position
`autonoma lsp hover <file> <line> <col>`	Get documentation and type info at position
`autonoma lsp analyze <file>`	Comprehensive file analysis (symbols, imports, functions)
`autonoma lsp callers <file> <fn> <line>`	Find all functions that call a given function
`autonoma lsp callees <file> <fn> <line>`	Find all functions called by a given function
`autonoma lsp impact <file> [function]`	Analyze impact of changes to a file or function

Example: Code Navigation

# List all symbols in a file
autonoma lsp symbols src/services/auth.go

# Go to definition of a symbol at line 25, column 10
autonoma lsp definition src/services/auth.go 25 10

# Find all references to a symbol
autonoma lsp references src/services/auth.go 25 10

# Get hover documentation
autonoma lsp hover src/services/auth.go 25 10

Example: Impact Analysis

# Check who calls a function before refactoring
autonoma lsp callers src/services/auth.go ValidateToken 45

# Check what functions are called by a function
autonoma lsp callees src/services/auth.go ValidateToken 45

# Full impact analysis for a file or function
autonoma lsp impact src/services/auth.go ValidateToken

# JSON output for scripting
autonoma lsp --json symbols src/services/auth.go

Sidecar Mode

For enterprise deployments, connect to a shared LSP sidecar service for better performance:

# Connect to shared LSP sidecar
autonoma lsp --sidecar http://lsp-sidecar:8080 symbols main.go

For detailed LSP documentation, see the LSP Integration Guide.

Background Agents

Delegate long-running tasks to background agents that continue working while you focus on other things.

Launch a Background Task

# Start a refactoring task in the background
autonoma task --background "Refactor all database queries to use prepared statements"

# Output:
# Background agent started: bg-task-abc123
# Output file: ~/.autonoma/background/bg-task-abc123.log

Manage Background Tasks

# List running background tasks
autonoma task list

# Check status of a specific task
autonoma task status bg-task-abc123

# View live output
autonoma task output bg-task-abc123 --follow

# Cancel a running task
autonoma task cancel bg-task-abc123

Key Features

• Session Persistence: Tasks survive CLI exit
• Real-time Progress: Stream output as agents work
• Cancellation: Stop tasks at any time
• NATS Coordination: Seamless multi-agent orchestration

Real-Time Event Streaming

Watch RIGOR execution progress in real-time with the --watch flag. Progress streams via Server-Sent Events with automatic reconnection.

Watch Execution Progress

# Watch a RIGOR execution in real-time
autonoma orchestrator-ai execute --task "review security" --watch

# Output:
#  RIGOR Progress: review-ai — exec-a1b2c3d4
#  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
#
#   Research    ✅ Completed   92%  3.2s
#   Inspect     ⏳ In Progress  —    —
#   Generate    ⬜ Pending      —    —
#   Optimize    ⬜ Pending      —    —
#   Review      ⬜ Pending      —    —

Watch an Existing Execution

# Watch a specific execution by ID
autonoma rigor status --execution exec-789 --watch

# Watch all active executions
autonoma orchestrator-ai status --watch

How It Works

• Server-Sent Events (SSE): Unidirectional streaming from Autonoma to your terminal
• Auto-Reconnect: If disconnected, automatically reconnects and catches up on missed events
• Phase Tracking: Shows confidence scores, duration, and error details per RIGOR phase
• GitHub PR Updates: Executions linked to PRs update the PR with progress comments

IDE Extensions

A6s extensions are available for 5 editors. Each connects to the local CLI daemon and implements the full DAEMON-PROTOCOL v1.0 — same 13 commands, any editor.

Quick Install

# VS Code
code --install-extension autonoma.autonoma-code

# JetBrains — Settings → Plugins → Marketplace → "A6s"

# Neovim (lazy.nvim)
{ "The-Autonoma/autonoma-nvim" }

# Emacs
(use-package autonoma :hook (prog-mode . autonoma-mode))

# Sublime Text — Package Control → A6s

Start the daemon first: a6s code --daemon

All Extensions Include

Agent Invocation

List, invoke, and manage 32 AI agents

Inline Code Actions

Explain, Refactor, Review, Generate Tests

Artifact Preview & Apply

Preview changes before writing to disk

RIGOR Progress

Real-time 5-phase execution tracking

Background Tasks

Launch, list, cancel, view output

Connection Status

Status bar/modeline indicator with auto-reconnect

Full extension documentation →

Multi-Agent Architecture

Unlike single-agent AI tools, Autonoma Code orchestrates 28 specialized agents working in parallel, each with domain expertise in areas like security, architecture, testing, and performance.

Agent	Capability	Specialization
`coder-ai`	BUILD	Code generation and implementation
`architect-ai`	BUILD	System design and architecture
`security-ai`	SECURE	Security audits and vulnerability detection
`tester-ai`	BUILD	Test generation and coverage
`debug-ai`	OPERATE	Bug investigation and fixes

See all 28 agents in the Architecture Documentation.

Authentication

Before using the CLI, you need to authenticate with your Autonoma account.

Login with API key

autonoma auth login --api-key YOUR_API_KEY

Get your API key from www.theautonoma.io after signing up.

Interactive login

autonoma auth login

Opens a browser for secure authentication.

Basic Commands

Create a new application

autonoma create "Build a task management app with user authentication"

Generates complete application code from natural language description.

Build from requirements file

autonoma build -f requirements.md

Builds application from detailed requirements in a markdown file.

Deploy to cloud

autonoma deploy --provider aws --region us-east-1

Deploys your application to the specified cloud provider.

Advanced Usage

Interactive mode

autonoma create --interactive

Starts an interactive session where you can refine requirements with AI assistance.

Specify technology stack

autonoma create "E-commerce platform" \
  --frontend react \
  --backend node \
  --database postgres \
  --auth oauth2

Generate specific components

autonoma generate component "User profile page with edit functionality"

Project Commands

Command	Description
`autonoma status`	Show current project status and build progress
`autonoma test`	Run generated tests
`autonoma optimize`	Optimize code for performance
`autonoma security-scan`	Run security vulnerability scan
`autonoma logs`	View deployment logs

CI/CD Integration

GitHub Actions

name: Deploy with Autonoma
on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Install Autonoma Code
        run: npm install -g @autonoma-io/code
      - name: Deploy
        run: autonoma deploy --provider aws
        env:
          AUTONOMA_API_KEY: ${{ secrets.AUTONOMA_API_KEY }}

GitLab CI

deploy:
  stage: deploy
  script:
    - npm install -g @autonoma-io/code
    - autonoma deploy --provider gcp
  variables:
    AUTONOMA_API_KEY: $AUTONOMA_API_KEY
  only:
    - main

Configuration

Create an autonoma.config.json file in your project root:

{
  "project": {
    "name": "my-app",
    "version": "1.0.0",
    "description": "Task management application"
  },
  "build": {
    "framework": "react",
    "language": "typescript",
    "outputDir": "./dist"
  },
  "deploy": {
    "provider": "aws",
    "region": "us-east-1",
    "scaling": {
      "min": 1,
      "max": 10,
      "targetCPU": 70
    }
  },
  "features": {
    "monitoring": true,
    "logging": true,
    "security": "enhanced"
  }
}

Deployment Providers

AWS

• EC2, Lambda, ECS
• Auto-scaling configured
• CloudFormation templates

Google Cloud

• Compute Engine, Cloud Run
• Kubernetes Engine
• Automatic load balancing

Azure

• App Service, Functions
• Container Instances
• ARM templates

DigitalOcean

• Droplets, App Platform
• Kubernetes
• Managed databases

Troubleshooting

Authentication

Authentication failed

Ensure your API key is valid. Run autonoma auth status to check, or re-authenticate with autonoma auth logout && autonoma auth login.

API key in CI/CD

Set AUTONOMA_API_KEY as an environment variable. Never commit API keys to source control.

Connection Issues

Cannot reach API

Verify connectivity with curl -s https://api.theautonoma.io/health. If behind a proxy, set HTTP_PROXY and HTTPS_PROXY environment variables.

Event stream disconnects

The --watch flag auto-reconnects on disconnect. If persistent, check your network stability or firewall settings for SSE/long-lived HTTP connections.

Agents & Tasks

Agent not responding

Check agent health with autonoma agents health --all. View logs with autonoma agents logs <agent-name> --tail 50. Use --verbose for detailed output.

Background task stuck

Check output with autonoma task output <task-id>. Force cancel with autonoma task cancel <task-id> --force.

Build timeout

Complex applications may take longer. Use --timeout 300 to increase the timeout, or use background tasks for long-running operations.

For additional help, run autonoma help [command] or visit our documentation. Report issues at github.com/autonoma/agent-cli/issues.

Ready to Build?

Start building your first application with Autonoma CLI

Get Started Free View Examples