ADL CLI

curl -fsSL https://raw.githubusercontent.com/inference-gateway/adl-cli/main/install.sh | bash

curl -fsSL https://raw.githubusercontent.com/inference-gateway/adl-cli/main/install.sh | bash -s -- --version v1.0.0

INSTALL_DIR=~/bin curl -fsSL https://raw.githubusercontent.com/inference-gateway/adl-cli/main/install.sh | bash

go install github.com/inference-gateway/adl-cli@latest

git clone https://github.com/inference-gateway/adl-cli.git
cd adl-cli
go install .

adl init my-weather-agent

apiVersion: adl.dev/v1
kind: Agent
metadata:
  name: my-weather-agent
  description: 'Provides weather information'
  version: '0.1.0'
spec:
  capabilities:
    streaming: true
  agent:
    provider: openai
    model: gpt-4o-mini
    systemPrompt: 'You are a helpful weather assistant.'
    maxTokens: 4096
    temperature: 0.7
  skills:
    - id: get_weather
      name: get_weather
      description: 'Get current weather for a city'
      schema:
        type: object
        properties:
          city:
            type: string
            description: 'City name'
        required: [city]
  server:
    port: 8080
    debug: false
  language:
    go:
      module: 'github.com/example/my-weather-agent'
      version: '1.25'

adl validate agent.yaml

adl generate --file agent.yaml --output ./my-weather-agent

cd my-weather-agent
task build
task run

# Interactive wizard
adl init my-agent

# Use defaults for all prompts
adl init my-agent --defaults

# Non-interactive with specific configuration
adl init my-agent \
  --name "Weather Agent" \
  --description "Provides weather information" \
  --provider openai \
  --model gpt-4o-mini \
  --language go \
  --flox

# Basic generation
adl generate --file agent.yaml --output ./my-agent

# Overwrite existing files (respects .adl-ignore)
adl generate --file agent.yaml --output ./my-agent --overwrite

# Generate with CI workflow
adl generate --file agent.yaml --output ./my-agent --ci

# Generate with CD pipeline
adl generate --file agent.yaml --output ./my-agent --cd

# Generate with AI assistant instructions
adl generate --file agent.yaml --output ./my-agent --ai

# Generate with CloudRun deployment
adl generate --file agent.yaml --output ./my-agent --deployment cloudrun

# Generate with Kubernetes deployment
adl generate --file agent.yaml --output ./my-agent --deployment kubernetes

# Full-featured generation
adl generate --file agent.yaml --output ./my-agent --ci --cd --deployment cloudrun --ai

# Validate a specific file
adl validate agent.yaml

# Validate default file
adl validate

apiVersion: adl.dev/v1
kind: Agent

apiVersion: adl.dev/v1
kind: Agent
metadata:
  name: advanced-agent
  description: 'Enterprise agent with full feature set'
  version: '1.0.0'
spec:
  capabilities:
    streaming: true
    pushNotifications: true
    stateTransitionHistory: true
  card:
    protocolVersion: '0.3.0'
    preferredTransport: 'JSONRPC'
    defaultInputModes: ['text', 'voice']
    defaultOutputModes: ['text', 'audio']
    url: 'https://my-agent.example.com:8443'
    documentationUrl: 'https://github.com/company/my-agent/docs'
    iconUrl: 'https://github.com/company/my-agent/icon.png'
  agent:
    provider: openai
    model: gpt-4o-mini
    systemPrompt: |
      You are a helpful assistant with enterprise capabilities.
      Always prioritize security and compliance.
    maxTokens: 8192
    temperature: 0.3
  config:
    database:
      connectionString: 'postgresql://user:pass@localhost:5432/db'
      maxConnections: '10'
      timeout: '30s'
    notifications:
      slackWebhook: 'https://hooks.slack.com/services/...'
      emailApiKey: 'your-email-api-key'
      retryAttempts: '3'
  services:
    database:
      type: service
      interface: DatabaseService
      factory: NewDatabaseService
      description: PostgreSQL database service for persistent storage
    notifications:
      type: service
      interface: NotificationService
      factory: NewNotificationService
      description: Multi-channel notification service
  skills:
    - id: query_database
      name: query_database
      description: 'Execute database queries with validation'
      tags: ['database', 'query', 'data']
      inject:
        - logger
        - database
      schema:
        type: object
        properties:
          query:
            type: string
            description: 'SQL query to execute'
          table:
            type: string
            description: 'Target table name'
          limit:
            type: integer
            description: 'Result limit'
            maximum: 1000
        required: [query, table]
    - id: send_notification
      name: send_notification
      description: 'Send multi-channel notifications'
      tags: ['notification', 'communication']
      inject:
        - logger
        - notifications
      schema:
        type: object
        properties:
          recipient:
            type: string
            description: 'Recipient identifier'
          message:
            type: string
            description: 'Message content'
          priority:
            type: string
            enum: ['low', 'medium', 'high', 'critical']
          channel:
            type: string
            enum: ['email', 'slack', 'teams', 'webhook']
        required: [recipient, message, priority, channel]
  server:
    port: 8443
    scheme: https
    debug: false
    auth:
      enabled: true
  language:
    go:
      module: 'github.com/company/advanced-agent'
      version: '1.25'
  acronyms: ['api', 'json', 'xml']
  scm:
    provider: github
    url: 'https://github.com/company/advanced-agent'
    github_app: true
    issue_templates: true
  sandbox:
    flox:
      enabled: true
    devcontainer:
      enabled: false
  deployment:
    type: cloudrun
    cloudrun:
      image:
        registry: gcr.io
        repository: advanced-agent
        tag: latest
        useCloudBuild: true
      resources:
        cpu: '2'
        memory: 1Gi
      scaling:
        minInstances: 1
        maxInstances: 100
        concurrency: 1000
      service:
        timeout: 3600
        allowUnauthenticated: false
        serviceAccount: agent@PROJECT_ID.iam.gserviceaccount.com
        executionEnvironment: gen2
      environment:
        LOG_LEVEL: info
        ENVIRONMENT: production
  hooks:
    post:
      - 'go mod tidy'
      - 'go generate ./...'

skills:
  - id: skill_id
    name: skill_name
    description: 'What the skill does'
    tags: ['tag1', 'tag2']
    examples:
      - 'Example usage text'
    inputModes: ['text']
    outputModes: ['text']
    inject:
      - logger
      - myService
    schema:
      type: object
      properties:
        param_name:
          type: string
          description: 'Parameter description'
      required: [param_name]

services:
  database:
    type: service
    interface: DatabaseService
    factory: NewDatabaseService
    description: PostgreSQL database service

inject:
  - logger # Built-in logger (always available)
  - config # Entire config object
  - config.database # Specific config subsection
  - myService # Custom service from spec.services

config:
  email:
    apiKey: ''
    fromAddress: '[email protected]'
skills:
  - name: send_email
    inject:
      - logger
      - config.email # Only email config is injected

language:
  go:
    module: 'github.com/company/my-agent'
    version: '1.25'

language:
  rust:
    packageName: 'my-agent'
    version: '1.88'
    edition: '2024'

language:
  typescript:
    packageName: 'my-agent'
    nodeVersion: '22'

config:
  database:
    connectionString: 'postgresql://localhost:5432/db'
    maxConnections: '10'
    timeout: '30s'
  notifications:
    slackWebhook: 'https://hooks.slack.com/...'
    retryAttempts: '3'

deployment:
  type: kubernetes

deployment:
  type: cloudrun
  cloudrun:
    image:
      registry: gcr.io
      repository: my-agent
      tag: latest
      useCloudBuild: true
    resources:
      cpu: '1'
      memory: 512Mi
    scaling:
      minInstances: 0
      maxInstances: 100
      concurrency: 1000
    service:
      timeout: 3600
      allowUnauthenticated: true
      serviceAccount: agent@PROJECT_ID.iam.gserviceaccount.com
      executionEnvironment: gen2
    environment:
      LOG_LEVEL: info

scm:
  provider: github

sandbox:
  flox:
    enabled: true

sandbox:
  devcontainer:
    enabled: true

hooks:
  post:
    - 'go mod tidy'
    - 'go generate ./...'
    - 'go fmt ./...'

acronyms: ['api', 'json', 'xml', 'url', 'http']

artifacts:
  enabled: true

scm:
  provider: github
  url: 'https://github.com/company/my-agent'
  github_app: true
  issue_templates: true

my-go-agent/
├── main.go                         # Main server setup
├── go.mod                          # Go module definition
├── config/
│   └── config.go                   # Type-safe configuration with env mapping
├── internal/
│   ├── logger/
│   │   └── logger.go               # Built-in logger factory
│   └── <service>/
│       └── <service>.go            # Custom service with interface
├── skills/
│   ├── query_database.go           # Skill implementations (TODO placeholders)
│   └── send_notification.go
├── Taskfile.yml                    # Build, test, lint, run tasks
├── Dockerfile                      # Multi-stage container build
├── .adl-ignore                     # File protection configuration
├── .well-known/
│   └── agent-card.json             # A2A agent discovery manifest
├── .github/
│   ├── workflows/
│   │   ├── ci.yml                  # CI workflow (with --ci)
│   │   └── cd.yml                  # CD workflow (with --cd)
│   └── ISSUE_TEMPLATE/             # Issue templates (when enabled)
├── .releaserc.yaml                 # Semantic-release config (with --cd)
├── k8s/
│   └── deployment.yaml             # Kubernetes manifest
├── .flox/                          # Flox environment (when enabled)
├── .devcontainer/
│   └── devcontainer.json           # DevContainer config (when enabled)
├── CLAUDE.md                       # AI instructions (with --ai)
├── .gitignore
├── .gitattributes
├── .editorconfig
└── README.md

my-rust-agent/
├── src/
│   ├── main.rs                     # Application entry point
│   └── skills/
│       ├── mod.rs                  # Module declarations
│       ├── query_database.rs       # Skill implementations
│       └── send_notification.rs
├── Cargo.toml                      # Rust package configuration
├── Taskfile.yml                    # Build, test, lint, run tasks
├── Dockerfile                      # Rust-optimized container
├── .adl-ignore                     # File protection
├── .well-known/
│   └── agent-card.json             # A2A agent discovery manifest
├── .github/workflows/
│   ├── ci.yml                      # CI workflow (with --ci)
│   └── cd.yml                      # CD workflow (with --cd)
├── .releaserc.yaml                 # Semantic-release config (with --cd)
├── k8s/
│   └── deployment.yaml             # Kubernetes manifest
├── CLAUDE.md                       # AI instructions (with --ai)
└── README.md

# Protect skill implementations
skills/*

# Protect specific files
main.go
config/config.go

# Protect by extension
*.go

# Protect directories
internal/

# Add your running agent to the gateway
infer agents add my-agent http://localhost:8080

# Verify the agent is connected
infer agents show my-agent

# Chat with the agent through the gateway
infer chat

adl generate --file ./path/to/agent.yaml

# Go
go mod tidy

# Rust
cargo build