Open source · MIT · runs on your machine

Your local AI ops cockpit.

A local-first control room for multi-model AI. Chat with local models, run MCP tool containers, launch parallel agents and watch the whole stack live, all from one Docker stack on your own machine.

$ docker compose -f config/docker-compose.yml up -d
Why motor-pool

One cockpit instead of five terminals.

Running local LLMs usually means juggling Ollama, a chat UI, container logs and a pile of scripts. motor-pool puts them in one place.

Local-first

Runs on your machine with Docker. Prompts go to your own models unless you add an external endpoint.

Multi-model

Ollama, Docker Model Runner, OpenLLM and any OpenAI-compatible endpoint, side by side.

Observable

Live service state, metrics, a WebSocket event stream and OpenTelemetry traces to Jaeger.

Extensible

Drop-in plugins, a declarative MCP registry and tool containers you start on demand.

Features

Everything the stack does, in one dashboard.

🪐

3D live hub

A Three.js map of your hub, services, models and sessions. Click any node to inspect it or start, stop, restart and pull models.

💬

Experience-aware chat

Persistent sessions with streaming replies, message history, replay mode and export, under a per-experience safety policy.

⚡

Your GPU, your models

Hardware detection picks a minimal, laptop or desktop profile, and an opt-in NVIDIA overlay runs Ollama on CUDA.

🔌

Bring your own endpoints

Add OpenRouter, vLLM, LM Studio or any OpenAI-compatible API with CUSTOM_LLM_ENDPOINTS. Keys stay server-side.

🎛️

Service lifecycle control

Start, stop and restart containers from the System panel through docker compose, with live health and port info per service.

🧰

MCP tool containers

Declare tools once in mcp-registry.json. motor-pool lists them with live health and starts them just in time.

🧩

Plugins in the agent loop

Drop a manifest into config/plugins/ and its tools join the model's tool list as plugin__tool calls.

🌳

Parallel agent worktrees

Launch agents into their own tmux window and git worktree so several can work on one repo without colliding. Opt-in, with an allowlist.

🗂️

Workspace IDE

Mount a project folder, then browse, edit and commit from a split-pane editor with a terminal, git log and artifacts tab.

📊

Metrics & tracing

Session, safety, feedback and error telemetry, a live event stream, and OTLP traces to Jaeger.

🛡️

Safety policies

Strict, standard and research policies per experience, with prompt-injection patterns, PII redaction and output sanitization.

🔥

Warm starts

An opt-in warmup service pre-loads your primary model during docker compose up, so your first message doesn't wait on a cold load.

💻 DeveloperFull model access, standard safety, tools on.
🔬 ResearcherLong-form reasoning, looser rails.
🛡️ Safe ChatStrict safety, simple UI for anyone.
🎬 Content StudioShort AI videos via the content-gen tool.
🌐 Website AgentLead discovery and site generation.
See it

Real screens from a running stack.

Captured from localhost:3000 with Ollama serving llama3.2:3b on a laptop RTX 3070.

motor-pool 3D hub showing services, the llama3.2 model and sessions
Hub · every service, model and session as a live graph
motor-pool chat session with a streamed answer from llama3.2
Chat · streamed replies from a local model
motor-pool system panel listing live services with restart and stop controls
System · live services with lifecycle controls
motor-pool metrics drawer with session, safety and error telemetry
Metrics · sessions, safety and error telemetry
How it works

A dashboard on top of your own containers.

The Express + React dashboard routes each session to an endpoint, applies the experience's policy, and streams events to the UI. Everything else is a container you control.

Browser

Hub, chat, System and Metrics panels, workspace IDE

→

motor-pool dashboard

Sessions · experience routing · safety policies · event bus · plugins · OpenTelemetry

→

Models LLM

Ollama (CPU/CUDA) · Docker Model Runner · OpenLLM · your endpoints

Tools MCP

content-gen · website · bb-mcp · plugins

State data

Postgres · encrypted endpoint store · Jaeger

Quick start

Up in one command.

You need Docker Desktop (or Docker Engine with Compose). The minimal stack is the dashboard, Ollama and Postgres, and fits on a 16 GB machine.

terminal
$ git clone https://github.com/nitsuah/motor-pool.git
$ cd motor-pool
$ cp .env.example .env && cp .env config/.env
$ docker compose -f config/docker-compose.yml up -d
# NVIDIA GPU? add the overlay:
$ docker compose -f config/docker-compose.yml \
    -f config/docker-compose.gpu.yml up -d
  1. Open localhost:3000. The hub shows what's running.
  2. Pick an experience chip: Developer, Researcher or Safe Chat.
  3. Chat with llama3.1:8b-instruct-q4_K_M, which ollama-init pulls automatically.
  4. Open System to start the optional tools, observability or sandbox profiles.
Roadmap

What's next.

2027 Q1 · DX & quality

  • Optional auth gate for LAN use
  • Scoped tokens for exec routes
  • Persistent BYOK endpoints
  • Per-service resource charts

2027 Q2 · MCP ecosystem

  • Blackboard agent demo mode
  • MCP container manager panel
  • Router integration for model pools
  • 3D memory palace (Neo4j)

2027 Q3 · Hardening

  • Multi-tenancy & RBAC
  • Audit logging
  • Decoupled runtimes
  • Guardrail policies

The full plan is in ROADMAP.md.

motor-pool

Local models, tools and agents — one cockpit.