MindsHub Cowork

MindsHub Cowork (this repository, mindsdb/minds, formerly the MindsDB project — mindsdb.com now 301-redirects to mindshub.ai) is a unified workspace for delegating full tasks — research, analysis, reporting, and recurring operations — to AI agents that hand back finished, shareable results instead of another chat transcript. The repository itself doesn’t hold the product’s application code directly; it is the platform superproject that pins together the four repositories making up the stack as git submodules — the Electron/web frontend (mindsdb/cowork), the FastAPI backend (mindsdb/cowork-server), the swappable agent runtime (mindsdb/anton), and the credentials vault (mindsdb/data-vault) — plus the Makefile-driven tooling to build, run, and package them together.

The core pitch is delegation over conversation: connect data sources such as BigQuery, Postgres, Gmail, Drive, HubSpot, Notion, and Linear through a scoped credentials vault so individual agent runs never see raw API keys, route each step of a task to whichever model fits — Anthropic, OpenAI, and Google’s frontier models alongside open models like DeepSeek, Qwen, and Kimi — through a built-in Model Router, and run the work via interchangeable open-source agent harnesses (Anton by default, with Hermes as an alternative). Output isn’t limited to text: Cowork produces documents, dashboards, and small apps as “artifacts” that can be published to a live URL, alongside cross-session memory, a reusable skill library, and scheduled recurring tasks.

It’s built to run anywhere: as a free desktop app for macOS and Windows, through the hosted web console, or fully self-hosted via the included docker-compose.yml — a FastAPI api service backed by SQLite plus an nginx-served web frontend that proxies API calls — with the Makefile also supporting a from-source developer workflow that keeps each submodule on its own feature branch without polluting the superproject’s git history. The whole repository, including its submodules, ships under the MIT license.

What You Get

• Unified task workspace - Delegate research, analysis, reporting, and recurring operations to agents and get back finished, shareable results instead of a chat transcript.
• Scoped data connectors - A credentials vault links tools like BigQuery, Postgres, Gmail, Drive, HubSpot, Notion, and Linear so agents can act on your data without ever seeing raw API keys.
• Model Router across providers - Switch per-task between frontier models (Claude, GPT, Gemini) and open models (DeepSeek, Qwen, Kimi) without wiring up separate API keys for each.
• Swappable open agent harnesses - Run the work through interchangeable open-source agents, Anton by default or Hermes as an alternative, selectable from a dropdown.
• Publishable artifacts - Turn agent output into documents, dashboards, and small apps, then publish them to a live shareable URL instead of pasting a chat log.
• Self-hostable deployment - Run the desktop app, the hosted web console, or your own Docker Compose stack (FastAPI + SQLite + nginx) for full control over data and infrastructure.

Common Use Cases

• Recurring reporting - Schedule an agent to pull data from connected sources on a cadence and publish a refreshed report artifact each time.
• Ad hoc research and analysis - Delegate a research question and receive a structured writeup or dashboard rather than a back-and-forth chat.
• Internal tool building without engineering - Non-technical operators build small internal apps or dashboards and publish them to a shareable URL.
• Cross-tool workflow automation - Route multi-step workflows that touch several connected systems, like pulling a HubSpot list and cross-referencing Notion, through one delegated task.
• Self-hosted/VPC deployment for data-sensitive teams - Run the full stack (frontend, API, agent runtime, vault) inside a private VPC or air-gapped environment via Docker Compose.

Under The Hood

Architecture The repo is a git-submodule superproject, not a monolithic codebase: frontend (mindsdb/cowork, the Electron/Vite app), backend/core_api (mindsdb/cowork-server, the FastAPI service run via uvicorn cowork.server:app), backend/core_agent (mindsdb/anton, the agent execution harness), and backend/data-vault (mindsdb/data-vault, tracked to its main branch rather than tag-pinned like the others). The Makefile is the real integration layer, stitching these together for local dev (hot-reload against both the API and agent packages plus the frontend dev server), for the packaged Electron app (installing cowork-server as a version-pinned uv tool), and for Docker (a multi-stage build that installs both Python submodules into one venv behind a single API process, alongside a separate nginx-served web image that proxies API calls). A shared SQLite database is explicitly called out as the sync point between the desktop server and the Electron app, with a documented warning that a schema migration applied on one side must exist on the other. Since the submodules were not fetched in this shallow, non-recursive clone, this assessment covers the orchestration layer rather than the application internals themselves.

Tech Stack The backend targets Python (3.12 in the container image, a wider 3.10-3.13 range per the README) behind an ASGI server, packaged and installed via uv, with SQLite as the datastore and a plain health-check endpoint. The frontend is an Electron and Vite-based Node application, built for both a desktop renderer and a web renderer, served in production behind nginx which reverse-proxies API traffic. The agent runtime ships as its own installable Python package, deliberately swappable per the README’s description of interchangeable open harnesses. Deployment targets include native desktop installers for macOS and Windows, a hosted web console, and a documented two-service Docker Compose stack for self-hosting. CI runs a language-aware CodeQL scan and a docs-only GitHub Pages deploy job.

Code Quality No application source or test files are present in this checkout — the real code lives in the submodules, which a shallow, non-recursive clone does not populate. What is visible is disciplined supporting tooling: multi-stage container builds that drop to a non-root user with an owned data directory, container health checks defined in more than one place, and a Makefile with self-documenting targets and stamp-file dependencies that avoid redundant reinstalls. No linter, type-checker, or test configuration is visible in the superproject itself, which is stated plainly here as a gap in what could be inspected rather than a claim about the submodule code.

What Makes It Unique The clearest engineering innovation visible in this repository is its submodule workflow: every submodule is set to ignore local commit drift so day-to-day feature-branch work in any module never shows up as noise in the superproject’s status, while a single environment-driven ref convention is obeyed identically by the local hot-reload path and the packaged Electron path, with pin changes gated behind one deliberate command. That is a genuine, specific solution to a common multi-repo pain point rather than a generic pattern. At the product level, the README and website differentiate on being an open-source, self-hostable workspace that routes across both frontier and open models and swaps entire agent harnesses rather than locking into one vendor’s agent — a credible claim from the documentation that could not be verified against runtime code in this checkout.

Self-Hosting

Licensing Model The repository is MIT licensed, and its README states the wider platform is designed to run anywhere — cloud, VPC, on-prem, air-gapped, or hybrid — with no license-key gating visible in this repo’s own files (Makefile, Docker Compose, Dockerfiles).

Self-Hosting Restrictions None found in this repository. The included docker-compose.yml and Dockerfiles run the full API and web stack with no license-key environment variables or gated feature flags.

Enterprise Features Not documented in this repository. The README mentions a paid “Pro” tier unlocking “all frontier models and private artifacts” on the hosted product, and separately mentions enterprise SLAs and custom deployments are available by contacting the team — but no self-hosted enterprise tier or feature list is described here.

Cloud vs Self-Hosted The hosted web console (console.mindshub.ai) and desktop app are the primary distribution channels promoted in the README; the self-hosted Docker Compose path is documented as a first-class option in this repo, with no functional gap called out between them here.

License Key Required No — nothing in this repository’s Docker Compose, Dockerfiles, or Makefile requires a license key to run the included services.