AutoBot is infrastructure you own, not a subscription.
A small, solid core. A management layer that runs the hard infrastructure for you.
Modules you install on top. Deploy it once, feed it your knowledge, connect whatever
LLM you trust, and run it forever — on your terms.

The Platform Model

AutoBot is three layers, bottom to top:

1. Platform Core — small, solid, and yours. Chat and streaming, a RAG knowledge
   base backed by a knowledge graph (your institutional memory), an LLM gateway with
   provider fallback, local inference, hooks, and governance (auth, RBAC, review gates,
   budgets). It changes slowly so everything above can depend on it.
2. Management Layer — Service Lifecycle Manager (SLM). Private AI has a lot of
   moving infrastructure: vector DB, cache, database, inference, and background workers,
   often across several machines. The Service Lifecycle Manager (SLM) owns the full
   lifecycle — deploy → operate → scale — so you can run it in production without
   becoming a full-time operator. (SLM means Service Lifecycle Manager, never "small
   language model.")
3. Modules — installable capabilities built on the core's bones. A module inherits
   institutional memory, local inference at zero marginal cost, hooks, and governance,
   so it stays small relative to what it delivers. Modules include AutoBot LLC (an
   autonomous agent-company), Codebase Analytics, and the Transcriber.

→ Full picture: The AutoBot Platform Model

Quick Start

Option A — One-line installer (recommended, full platform). Deploys the Service
Lifecycle Manager (SLM) and all dependencies:

curl -fsSL https://raw.githubusercontent.com/mrveiss/AutoBot-AI/main/install.sh | sudo bash

When it finishes, the installer prints your SLM URL (https://<server-ip>/slm/) and
admin credentials. Open that URL and log in — the Setup Wizard then walks you through
adding fleet nodes, enrolling agents, assigning roles, and provisioning.

Option B — Docker Compose (quick eval / development).

git clone https://github.com/mrveiss/AutoBot-AI.git
cd AutoBot-AI
cp .env.example .env
docker compose up -d

User UI at http://localhost, SLM admin at http://localhost/slm.

→ Full install options and the two-phase deployment flow: INSTALL.md.

What AutoBot Does

AutoBot is a self-hosted AI platform: conversational AI, a private knowledge base,
and the machinery to deploy and operate it all on your own hardware. You keep complete
control:

• Unified Self-Hosted Dashboard — manage AI, infrastructure, fleet operations, and
  analytics from one place on your servers
• Natural Language Control — issue commands in plain English; AutoBot handles the
  complexity locally
• Self-Hosted Knowledge Bases — build knowledge bases from your docs, code, runbooks,
  and workflows — RAG-indexed and stored locally
• Vision Processing — analyze screenshots and diagrams locally to guide decisions
• Self-Hosted Fleet Management — deploy, operate, and scale multi-server stacks with
  the Service Lifecycle Manager (SLM)
• Installable Modules — extend the platform with AutoBot LLC (an autonomous
  agent-company), Codebase Analytics, the Transcriber, and more
• Complete Data Privacy — full data control, no external dependencies, runs entirely
  on your hardware, no vendor lock-in

→ Browse everything in the Capability Catalog.

System Requirements

Platform Core: Features at a Glance

Management Layer: the Service Lifecycle Manager (SLM)

The Service Lifecycle Manager (SLM) is how AutoBot runs the infrastructure behind
private AI for you. It owns the full lifecycle of the stack — vector DB, cache, database,
inference, and workers — across one or more machines:

The SLM dashboard lives at http://localhost/slm. See
SLM deployment.

Modules

Modules are large capabilities you install on the core. Because they inherit the core's
institutional memory, local inference, hooks, and governance, they stay small relative to
what they deliver.

• AutoBot LLC — an autonomous agent-company: define a company of AI agents (and
  human co-workers), give them goals and a backlog, schedule them to work autonomously,
  and govern their spend. See AutoBot LLC.
• Codebase Analytics — understand codebases, extract insights, and identify risks
  entirely on your own hardware: code structure analysis, risk detection, and dependency
  insights, with no source ever leaving your machines.
• Transcriber — a general-purpose audio transcription module: organize projects and
  recordings, transcribe locally, and export transcripts.

→ Browse all capabilities in the Capability Catalog.

Why Self-Hosted

AutoBot keeps your AI and your data on infrastructure you control:

• Data privacy & compliance — your data never leaves your hardware; supports HIPAA,
  GDPR, and SOC2 requirements
• Predictable cost — local inference runs at zero marginal cost per request; no
  per-request fees
• Full control — run custom models, modify the code, no vendor lock-in
• Low latency — local inference and command execution, no network round-trip
• Scale on your terms — grow within your own infrastructure with the SLM

📚 Learn more: Why Self-Hosted Infrastructure Automation?

Architecture Overview

Full diagrams (data flows, deployment topologies, sequence diagrams): docs/architecture/system-diagram.md
The conceptual model (core → SLM → modules): docs/architecture/PLATFORM_MODEL.md
Feature walkthroughs and demo recording scripts: docs/DEMOS.md

graph TB
    User["👤 User<br/>(Browser)"]
    Frontend["🎨 Frontend<br/>(Vue.js)"]
    Backend["⚡ Backend<br/>(FastAPI)"]

    Redis["🔴 Redis<br/>(Cache/Queue)"]
    PostgreSQL["🐘 PostgreSQL<br/>(Data)"]
    ChromaDB["🔍 ChromaDB<br/>(Vectors)"]

    Inference["🧠 Local LLM<br/>(Ollama inference)"]

    SLM["🛠️ Service Lifecycle Manager<br/>(deploy · operate · scale)"]
    Ansible["🔧 Ansible<br/>(Fleet Ops)"]
    Browser["🌐 Browser Automation<br/>(Chromium)"]

    User -->|HTTP/WS| Frontend
    Frontend -->|API| Backend

    Backend -->|Read/Write| Redis
    Backend -->|Query| PostgreSQL
    Backend -->|Vector Search| ChromaDB
    Backend -->|Inference| Inference

    Backend -->|Control| Browser
    SLM -->|Manages lifecycle of| Backend
    SLM -->|Executes| Ansible

    style User fill:#e1f5ff
    style Frontend fill:#f3e5f5
    style Backend fill:#fff3e0
    style Redis fill:#ffebee
    style PostgreSQL fill:#e8f5e9
    style ChromaDB fill:#fce4ec
    style Inference fill:#f1f8e9
    style SLM fill:#ede7f6
    style Ansible fill:#ede7f6
    style Browser fill:#e0f2f1

Deployment Options

Docker (Recommended for Most Users)

Fastest way to get started. Includes all services pre-configured.

docker compose up -d

Native Installation

For development or custom setups. See INSTALL.md.

Development Mode

For contributing to AutoBot:

docker compose -f docker-compose.dev.yml up -d

Core Services

AutoBot runs as a coordinated set of services:

Usage Guide

Dashboard Overview

Once running, navigate to http://localhost to access:

• Chat Interface — start conversing with AutoBot about your knowledge and infrastructure
• Knowledge Bases — upload and manage documents, codebases, runbooks
• Workflows — create automated tasks and operations
• Fleet Management — view and orchestrate multiple servers
• Analytics — monitor system health, performance, and activity

The Service Lifecycle Manager (SLM) — AutoBot's management layer for deploying,
operating, and scaling your AI infrastructure (vector DB, cache, database, inference, and
workers) — lives at http://localhost/slm.

Example: Managing a Fleet

# In the AutoBot chat:
# "Deploy the latest application version to all production servers"
# AutoBot handles the Ansible orchestration automatically

Example: Infrastructure Insights

# Ask AutoBot to analyze your codebase:
# "What are the critical dependencies in the auth module?"

Configuration

All configuration uses environment variables in .env. See .env.example for all options.

Key settings:

• AUTOBOT_DEPLOYMENT_MODE — hybrid or distributed
• AUTOBOT_LLM_PROVIDER — ollama (default) or others

LLM Providers and Fallback

AutoBot's LLM gateway supports local and hosted providers (Ollama, OpenAI, Anthropic,
Groq, vLLM, HuggingFace, and OpenRouter). When a model hits a rate limit or quota cap,
requests automatically route to a backup model via configurable fallback chains.

• LLM Fallback Configuration — configure fallback chains, tune rate limits, and troubleshoot quota issues
• Environment Variables Reference — full variable listing including AUTOBOT_FALLBACK_CHAIN_* and AUTOBOT_LLM_RL_*

Contributing

We welcome contributions! Whether you're fixing bugs, adding features, or improving documentation:

1. Check out CONTRIBUTING.md for guidelines
2. Look for issues tagged good-first-issue if you're new
3. Join the community discussion in GitHub Discussions

Support

• 💬 Questions? Start a discussion in GitHub Discussions
• 🐛 Found a bug? Open an issue
• 💡 Have an idea? Share it in Discussions → Ideas

How to Contribute

AutoBot is open source and we welcome contributions from the community! Whether you're fixing bugs, adding features, or improving documentation, your contributions help build a better self-hosted AI platform for everyone.

🚀 For Beginners (New to Open Source)

Start with good-first-issue labeled tasks. These are:

• Self-contained and beginner-friendly
• Expected to take less than 2 hours
• Perfect for learning the codebase
• Great introduction to our contribution process

💻 For Experienced Developers

Find issues matching your skill area:

• 🎨 Frontend (Vue.js, TypeScript, CSS, Vite)

  • Help Wanted: Frontend
  • All Frontend Issues

• 🔧 Backend (FastAPI, Python, APIs, Databases)

  • Help Wanted: Backend
  • All Backend Issues

• 🚀 Infrastructure & DevOps (Docker, Ansible, CI/CD, Deployment)

  • Help Wanted: Infrastructure
  • All Infrastructure Issues

• 📚 Documentation (Guides, Examples, README, API Docs)

  • Help Wanted: Docs
  • All Docs Issues

• 🧪 Testing & QA (Unit Tests, Integration Tests, Test Coverage)

  • Help Wanted: Testing
  • All Testing Issues

📖 Step-by-Step Contribution Guide

Detailed contribution process, code style guidelines, and development setup:
→ Read CONTRIBUTORS.md

Sponsors & Supporters

Support AutoBot's development in multiple ways:

Sponsorship & Donations

• GitHub Sponsors — Recurring sponsorship with direct support and updates
• Ko-fi — One-time or recurring donations for maintenance and features

Your support helps us:

• Maintain and improve the codebase
• Add new features and capabilities
• Expand documentation and examples
• Grow the community
• Enable contributors to participate

License

AutoBot is open source under the Apache License 2.0. Free forever for
everyone — use it, modify it, distribute it, and profit from it, no permission or fees
required. Attribution is required (see NOTICE), and the "AutoBot" / "mrveiss"
names may not be used to endorse derived products without permission.

Free forever for individuals and hobbyists. Nothing you can do with AutoBot today
becomes paid tomorrow. Production support is how we keep it funded — see
FUNDING.md.

Production support & funding

AutoBot is free to run forever. Paid production support (Community / Production Support /
Compliance Pack) is how the project stays funded — tier definitions, sponsorship links, and
the support contact path live in FUNDING.md.

Roadmap

Shipped

• Multi-user authentication and RBAC (single-user mode retired)

Upcoming

• Kubernetes orchestration support
• Advanced analytics dashboards
• Module ecosystem and registry
• Mobile companion app

Under Consideration

• Cloud deployment templates
• Managed hosting option
• Enterprise features (SAML, audit logs)

Technology Stack

• Frontend: Vue.js, TypeScript, Vite
• Backend: FastAPI, Python, AsyncIO
• Database: PostgreSQL, Redis, ChromaDB
• Inference: Ollama (local), LangChain
• Orchestration: Ansible, Docker, Kubernetes (coming)
• Infrastructure: Docker Compose, systemd

Documentation

• Documentation Index — the full documentation home
• The AutoBot Platform Model — core → SLM → modules
• Capability Catalog — everything AutoBot can do
• INSTALL.md — detailed setup instructions
• CONTRIBUTING.md — get involved

Status

Current Version: v1.5.0 (Active Development)

AutoBot is actively developed and used for self-hosted AI and infrastructure automation.
It's suitable for:

• ✅ Self-hosted deployments on your infrastructure
• ✅ Development and testing environments
• ✅ Learning AI-driven automation
• 🚀 Production use (with monitoring and backups)

Made with ❤️ by the AutoBot community