LocalAGI

Your AI. Your Hardware. Your Rules

Create customizable AI assistants, automations, chat bots and agents that run 100% locally. No need for agentic Python libraries or cloud service keys, just bring your GPU (or even just CPU) and a web browser.

LocalAGI is a powerful, self-hostable AI Agent platform that allows you to design AI automations without writing code. Create Agents with a couple of clicks, connect via MCP, and use built-in Skills (manage skills in the Web UI and enable them per agent). Every agent exposes a complete drop-in replacement for OpenAI's Responses APIs with advanced agentic capabilities. No clouds. No data leaks. Just pure local AI that works on consumer-grade hardware (CPU and GPU). Skills follow the skillserver format and can be created, imported, or synced from git.

️ Take Back Your Privacy

Are you tired of AI wrappers calling out to cloud APIs, risking your privacy? So were we.

LocalAGI ensures your data stays exactly where you want it—on your hardware. No API keys, no cloud subscriptions, no compromise.

Key Features

• No-Code Agents: Easy-to-configure multiple agents via Web UI.
• Web-Based Interface: Simple and intuitive agent management.
• Advanced Agent Teaming: Instantly create cooperative agent teams from a single prompt.
• Connectors: Built-in integrations with Discord, Slack, Telegram, GitHub Issues, and IRC.
• Comprehensive REST API: Seamless integration into your workflows. Every agent created will support OpenAI Responses API out of the box.
• Short & Long-Term Memory: Built-in knowledge base (RAG) for collections, file uploads, and semantic search. Manage collections in the Web UI under Knowledge base; agents with "Knowledge base" enabled use it automatically (implementation uses LocalRecall libraries).
• Planning & Reasoning: Agents intelligently plan, reason, and adapt.
• Periodic Tasks: Schedule tasks with cron-like syntax.
• Memory Management: Control memory usage with options for long-term and summary memory.
• Multimodal Support: Ready for vision, text, and more.
• Extensible Custom Actions: Easily script dynamic agent behaviors in Go (interpreted, no compilation!).
• Built-in Skills: Manage reusable agent skills in the Web UI (create, edit, import/export, git sync). Enable "Skills" per agent to inject skill tools and the skill list into the agent.
• Fully Customizable Models: Use your own models or integrate seamlessly with LocalAI.
• Observability: Monitor agent status and view detailed observable updates in real-time.

️ Quickstart

…

Now you can access and manage your agents at http://localhost:8080

Still having issues? see this Youtube video: https://youtu.be/HtVwIxW3ePg

Videos

Local Stack Family

LocalAI is now part of a comprehensive suite of AI tools designed to work together:

  </a>
</td>
<td width="50%" valign="top">
  <h3><a href="https://github.com/mudler/LocalAI">LocalAI</a></h3>
  <p>LocalAI is the free, Open Source OpenAI alternative. LocalAI act as a drop-in replacement REST API that's compatible with OpenAI API specifications for local AI inferencing. Does not require GPU.</p>
</td>

  </a>
</td>
<td width="50%" valign="top">
  <h3><a href="https://github.com/mudler/LocalRecall">LocalRecall</a></h3>
  <p>A REST-ful API and knowledge base management system. LocalAGI embeds this functionality: the Web UI includes a <strong>Knowledge base</strong> section and the same collections API, so you no longer need to run LocalRecall separately.</p>
</td>

️ Hardware Configurations

LocalAGI supports multiple hardware configurations through Docker Compose profiles:

CPU (Default)

• No special configuration needed
• Runs on any system with Docker
• Best for testing and development
• Supports text models only

NVIDIA GPU

• Requires NVIDIA GPU and drivers
• Uses CUDA for acceleration
• Best for high-performance inference
• Supports text, multimodal, and image generation models
• Run with: docker compose -f docker-compose.nvidia.yaml up
• Default models:
  • Text: gemma-3-4b-it-qat
  • Multimodal: moondream2-20250414
  • Image: sd-1.5-ggml
• Environment variables:
  • MODEL_NAME: Text model to use
  • MULTIMODAL_MODEL: Multimodal model to use
  • IMAGE_MODEL: Image generation model to use
  • LOCALAI_SINGLE_ACTIVE_BACKEND: Set to true to enable single active backend mode

Intel GPU

• Supports Intel Arc and integrated GPUs
• Uses SYCL for acceleration
• Best for Intel-based systems
• Supports text, multimodal, and image generation models
• Run with: docker compose -f docker-compose.intel.yaml up
• Default models:
  • Text: gemma-3-4b-it-qat
  • Multimodal: moondream2-20250414
  • Image: sd-1.5-ggml
• Environment variables:
  • MODEL_NAME: Text model to use
  • MULTIMODAL_MODEL: Multimodal model to use
  • IMAGE_MODEL: Image generation model to use
  • LOCALAI_SINGLE_ACTIVE_BACKEND: Set to true to enable single active backend mode

Customize models

You can customize the models used by LocalAGI by setting environment variables when running docker-compose. For example:

# CPU with custom model
MODEL_NAME=gemma-3-12b-it docker compose up

# NVIDIA GPU with custom models
MODEL_NAME=gemma-3-12b-it \
MULTIMODAL_MODEL=moondream2-20250414 \
IMAGE_MODEL=flux.1-dev-ggml \
docker compose -f docker-compose.nvidia.yaml up

# Intel GPU with custom models
MODEL_NAME=gemma-3-12b-it \
MULTIMODAL_MODEL=moondream2-20250414 \
IMAGE_MODEL=sd-1.5-ggml \
docker compose -f docker-compose.intel.yaml up

# With custom actions directory
LOCALAGI_CUSTOM_ACTIONS_DIR=/app/custom-actions docker compose up

If no models are specified, it will use the defaults:

• Text model: gemma-3-4b-it-qat
• Multimodal model: moondream2-20250414
• Image model: sd-1.5-ggml

Good (relatively small) models that have been tested are:

• qwen_qwq-32b (best in co-ordinating agents)
• gemma-3-12b-it
• gemma-3-27b-it

Why Choose LocalAGI?

• ✓ Ultimate Privacy: No data ever leaves your hardware.
• ✓ Flexible Model Integration: Supports GGUF, GGML, and more thanks to LocalAI.
• ✓ Developer-Friendly: Rich APIs and intuitive interfaces.
• ✓ Effortless Setup: Simple Docker compose setups and pre-built binaries.
• ✓ Feature-Rich: From planning to multimodal capabilities, connectors for Slack, MCP support, built-in Skills, LocalAGI has it all.

Screenshots

Powerful Web UI

Connectors Ready-to-Go

Full Documentation

Explore detailed documentation including:

• Installation Options
• REST API Documentation
• Connector Configuration
• Agent Configuration
• Skills

Environment Configuration

LocalAGI supports environment configurations. Note that these environment variables needs to be specified in the localagi container in the docker-compose file to have effect.

For the built-in knowledge base, optional env (defaults use LOCALAGI_STATE_DIR): COLLECTION_DB_PATH, FILE_ASSETS, VECTOR_ENGINE (e.g. chromem, postgres), EMBEDDING_MODEL, DATABASE_URL (when VECTOR_ENGINE=postgres).

Skills are stored in a fixed skills subdirectory under LOCALAGI_STATE_DIR (e.g. /pool/skills in Docker). Git repo config for skills lives in that directory. No extra environment variables are required.

Installation Options

Pre-Built Binaries

Download ready-to-run binaries from the Releases page.

Source Build

Requirements:

• Go 1.20+
• Git
• Bun 1.2+

# Clone repo
git clone https://github.com/mudler/LocalAGI.git
cd LocalAGI

# Build it
cd webui/react-ui && bun i && bun run build
cd ../..
go build -o localagi

# Run it
./localagi

Using as a Library

LocalAGI can be used as a Go library to programmatically create and manage AI agents. Let's start with a simple example of creating a single agent:

…

This basic example shows how to:

• Create a single agent with essential configuration
• Set up the agent's model and API connection
• Configure basic features like knowledge base and reasoning
• Start and stop the agent

For managing multiple agents, you can use the AgentPool system:

…

Key features available through the library:

• Single Agent Management: Create and manage individual agents with basic configuration
• Agent Pool Management: Create, start, stop, and remove multiple agents
• Configuration: Customize agent behavior through AgentConfig
• Actions: Define custom actions for agents to perform
• Connectors: Add custom connectors for external services
• Dynamic Prompts: Create dynamic prompt templates
• Job Filters: Implement custom job filtering logic
• Status Tracking: Monitor agent status and history
• State Persistence: Automatic state saving and loading

For more details about available configuration options and features, refer to the Agent Configuration Reference section.

Extending LocalAGI

LocalAGI provides two powerful ways to extend its functionality with custom actions:

1. Custom Actions (Go Code)

LocalAGI supports custom actions written in Go that can be defined inline when creating an agent. These actions are interpreted at runtime, so no compilation is required.

Automatic Custom Actions Loading

You can also place custom Go action files in a directory and have LocalAGI automatically load them. Set the LOCALAGI_CUSTOM_ACTIONS_DIR environment variable to point to a directory containing your custom action files. Each .go file in this directory will be automatically loaded and made available to all agents.

Example setup:

# Set the environment variable
export LOCALAGI_CUSTOM_ACTIONS_DIR="/path/to/custom/actions"

# Or in docker-compose.yaml
environment:
  - LOCALAGI_CUSTOM_ACTIONS_DIR=/app/custom-actions

Directory structure:

custom-actions/
├── weather_action.go
├── file_processor.go
└── database_query.go

Each file should contain the three required functions (Run, Definition, RequiredFields) as described below.

How Custom Actions Work

When creati