Auto Learning Agents Documentation

What Auto Learning Agents Is

Auto Learning Agents is an operating system for AI agents. You define the agents: what each one does, how often it runs, and which AI model it uses. The platform runs them in parallel as supervised processes, gives each one persistent memory and conversation history, learns from the work they produce, and flags anything that needs a human decision. Everything runs on your own hardware, under your own keys, with all of your data in a local database you own.

The platform is not a wrapper around a single AI call, and it is not built around any one job. The heart of the system is the structure: a conversational master agent you steer everything through, a dynamic context system that gives every agent the right history at the right moment, a memory bank that accumulates what the system learns, multi-pass pipelines for coding and research, and a web UI that shows you all of it live. Automated agents sit on top of that structure as focused, recurring sessions you create for whatever you need done. Ready-made presets ship for common roles like outreach, support intake, and social engagement, and they are exactly that, presets. You can run any number of agents of any kind side by side, point each one at its own instructions file, and keep adding new kinds as your needs grow.

A core design idea runs through everything: the AI models are replaceable workers, and the system is the structure around them. Every agent gets its instructions from an editable file, its context from the conversation system, and its abilities from a shared tool layer. That means you can swap models per agent, tune how often each agent thinks, and control cost with precision, all without changing how the system behaves.

How the System Is Organized

Under the hood, Auto Learning Agents is a single Elixir/OTP application built as a supervision tree. Each part of the system is a supervised node with its own tick rate, pause state, and conversation history, so one busy or failing component never takes down the rest. The supervisor restarts anything that stops, which is what makes the platform safe to leave running for weeks at a time.

The nodes you will meet throughout these docs:

Master agent. Your conversation interface. It is event-driven, answers immediately, knows the whole system, and can queue work, manage pauses, and walk you through setting up each area. Task agents. The recurring agents you define, each on its own timer with its own model. Impulse. The autonomous layer that reviews activity, watches for problems, and works your goals on its own schedule. Coding and research pipelines. Queue-fed, multi-pass workers for development tasks and verified research. Chatbot. A fast poller that connects messaging platforms like Discord, Slack, WhatsApp, and Telegram. Learning and schedule nodes. Background maintenance: model training, data curation, report pulls, and cleanup. Memory bank and analysis services. Always-on Python services that handle embeddings, topic classification, and anomaly detection.

Every tick rate is configurable, config files hot-reload, and agent changes apply while the system runs. The PHP and Python tool layer, roughly 70 tools, does the real-world work: email, social platforms, browsing, scraping, deployments, and more. Agents call tools, tools act, and results flow back into memory.

Quick Start

The fastest path is Docker. The image bundles the Elixir runtime, the Python services, the local database, and the full tool layer:

git clone https://github.com/AIAppsAPI/auto-learning-agents
cd auto-learning-agents
cp .env.example .env
docker-compose up -d

After the container starts, log in to Claude and open the UI:

docker compose exec -u ala ala claude login

The web UI is at http://localhost:80. From there the master agent can walk you through everything else. The Docker installation guide covers the details, and the server installation guide covers running the platform directly on a Linux server with systemd. You need Docker and at least one way for the agents to think: an API key from a provider like Anthropic or OpenAI, or a local model served through Ollama.

What Self-Hosting Means Here

Self-hosted is a promise the platform takes literally. The whole stack runs on your machine: the Elixir application, the Python embedding and analysis services, the PHP and Python tools, the web UI, and a single local database that holds your conversations, memory, contacts, and configuration. There is no required cloud account, no telemetry, and no external service in the data path. The only outbound traffic is the traffic you configure: calls to the AI providers you choose, and the channels your agents work, like your email provider or your social platforms. Move the install directory and you have moved the system, back it up and you have backed up everything it knows.

Your model access works the same way. Bring an Anthropic or OpenAI subscription, or run fully local with Ollama and keep every token on your own hardware. Mixed setups are normal: many installs run a strong hosted model for the master agent and the pipelines, and cheap local models for high-frequency background agents. The license matches the philosophy, AGPL-3.0, free to self-host and modify for your own use, with a commercial license available for companies that want to embed the platform in a product or offer it as a hosted service.

The Web UI at a Glance

The whole system runs from the browser. The Dashboard shows system state, your agents with live status lanes, an activity timeline, and notes the autonomous layer leaves for you. Chat is the master agent: multiple named conversations, file uploads, microphone input, a model picker, and spoken replies. Files is a full file browser over the install with a code editor. Goals holds the goal list the system works toward. Knowledge is where you browse the memory bank, review what the system has learned, and manage knowledge bases. Config covers agents, models, API keys, per-area settings, users, and voice.

The sidebar carries a live activity feed, the global pause button, and a flag counter. Flags are the human-attention mechanism that runs through the whole platform: when any agent meets something that needs your judgment, it writes a flag, and you review it in the UI or simply ask the master agent about it. The web UI guide tours every screen.

The Tool Layer

Agents act on the world through tools, and the platform ships with roughly 70 of them in a single shared directory. The highlights give a sense of the range: a complete email and SMS marketing system with sequences, sending windows, and engagement tracking; multi-platform social posting, monitoring, and analytics across seven networks; customer service intake over IMAP and web forms with knowledge base lookups; a stealth headless browser with fingerprint profiles and persistent sessions; BrightData scraping APIs for the major platforms and Google results; full PTY terminal sessions for driving interactive programs; SSH management for remote servers with file transfer and rsync; a website builder that deploys to S3 and API backends; Google Analytics and Search Console reporting; voice transcription and speech synthesis; a mixture tool that asks several AI models the same question and synthesizes the answers; and a delegation tool that spawns a focused child agent with its own isolated context.

Every tool is a plain command-line program, which is exactly why the system stays extensible. Each tool documents its own parameters when called, agents learn invocations once and save them to the memory bank, and agents are allowed to add new tools to the directory as they discover what they need. The tools guide covers the layer in detail, and integrations covers connecting the external services the tools talk to.

Memory and Learning

Three layers keep the system smart, and they are worth keeping distinct as you read these docs. The memory bank is searchable long-term knowledge: facts, lessons, procedures, people, and projects, stored across six entry types. All agents query it before acting and save what they learn after. The conversation system is dynamic context: every turn of every conversation is stored, embedded, and topic-classified, so agents always receive the right recent history, and topics get AI-written digests you can pin into context. Instruction files are behavior: plain markdown files that define what each agent is and how it should act, all editable from the UI.

On top of those layers, the learning layer tracks outcomes, curates training data, detects anomalies, and extracts patterns from successful work into rewards, so the system measurably improves at your tasks over time. The default memory backend is local and works out of the box. When you want knowledge graphs, multi-strategy retrieval, and automatic consolidation, Adaptive Recall plugs in as a one-line settings change.

Cost and Model Control

Cost control is built into the architecture rather than bolted on. Every agent and every pipeline has two dials: which model it uses and how often it ticks. A support intake agent that checks email every ten minutes can run on a small, inexpensive model, while the coding pipeline that ships your features runs on a top-tier model with a high effort level. The model keys cover Claude Sonnet and Opus with selectable effort levels, OpenAI Codex models from mini to extra-high effort, and any local model you serve through Ollama, where the only cost is your own electricity.

Because instructions, memory, and tools live in the system rather than in any model, switching an agent to a different model is a one-field change, in the Config tab or the config file, and applies live. That makes it practical to start cheap, measure what each agent actually needs, and upgrade only the agents where the stronger model earns its cost. Pausing is the final dial: anything autonomous can be paused individually or globally, so spend is always something you can stop in one click. The AI models guide covers every key and where each one fits.

Staying in Control

Autonomy is opt-in at every level. Each agent ships disabled until you enable it, each agent has its own pause button, and one global pause stops all autonomous activity at once, from the sidebar or by telling the master agent to pause everything. A Kill Now control stops any mid-task run immediately. Outward-facing work has its own guardrails: social posting defaults to an approval queue, support answers come only from your verified knowledge base, and marketing enforces unsubscribe compliance on every send. Anything that needs human judgment becomes a flag for your review. The pause and safety guide covers the full model.

Browse the Documentation

Getting Started

Core System

Automated Agents

Pipelines and Capabilities

Operations

Reference

Where to Start

If you are installing for the first time, start with the Docker installation, then skim configuration and pick your models in AI models. Your first conversation with the master agent is the best tour of the system, it knows everything in these docs and can set up each area with you interactively.

If your install is running and you want it doing real work, read creating agents to define your first automated agent, or switch on one of the presets and follow its guide. Queue something into the coding pipeline or the research pipeline to see the multi-pass workflow in action.

If you are evaluating the platform, the features list and the FAQ answer the common questions, and the source on GitHub is always the final word. The platform is AGPL-3.0, free to self-host and modify, with commercial licensing available for companies that want to embed it or offer it as a service.