MindsHub Cowork
A unified workspace that turns connected data and interchangeable AI models into finished, shareable work.
The README states that credentials are scoped per connection and raw keys are hidden from agents, while the CodeQL workflow uses relatively narrow GitHub permissions, providing some support for least privilege and sensitive-data handling. However, the files do not expose the agent runtime permission model, vault implementation, retention rules, or outbound-data controls. Connections, public URL publishing, and scheduled operations are described without per-action confirmation, preview, or approval controls. Explicit confirmation evidence is largely confined to the destructive make flush command; it permanently removes conversations and keys, and reinstalling software is not data rollback. The MIT notice, corporate copyright, security email, and support channels provide attribution, while publisher identity remains unknown as stipulated.
Pinned submodule commits, unified make commands, and a stated Python range support ordinary dependency availability, but no lockfiles, submodule contents, or installation failure handling are supplied. Self-consistency is weakened because the assessed repository is mindsdb/mindshub while the README clones mindsdb/minds, and the material alternates among MindsHub, Cowork, MindsDB, and Anton; the security version series is also not tied clearly to this product. Failure guidance is limited to reinstalling, flushing state, or filing an issue, with no evidence of actionable runtime error messages.
The README thoroughly identifies knowledge-worker audiences and scenarios including research, reports, applications, dashboards, and scheduled operations. It also describes desktop, web, source, hosted, local, VPC, air-gapped, and hybrid modes plus interchangeable models and agent harnesses, although much of this environment support is asserted without configuration or compatibility details. Components and deployment modes provide partial capability boundaries, but the product's non-capabilities are not stated. Scheduling is advertised without trigger conditions, permission scope, duplicate-run safeguards, or human-approval rules.
The README has strong information architecture covering onboarding, capabilities, components, builds, deployment, support, security, contribution, and licensing. Installation commands, operating modes, submodule workflows, and the make flush warning are concrete. The complete MIT text justifies full license credit. Deductions reflect unstable naming and update paths: the repository and clone target differ, several product names coexist, and only a release badge and broad security-version statement are supplied instead of a revision-specific changelog or coherent version policy. Examples are mostly commands and scenario lists rather than end-to-end tasks or an FAQ. Limitations are confined largely to destructive cleanup and component licensing. Maintenance channels exist, but ownership, response targets, and component responsibility remain vague.
The source says agent results can become documents, dashboards, applications, code, and shareable URLs, giving reasonable support for output usability. A unified workspace, model switching, connected data, and persistent memory indicate plausible marginal value over a basic chat interface. These are principally product claims, however, without example artifacts, implementation excerpts, or static test evidence. Cost-benefit treatment only mentions a free starting tier, Pro model access, and self-hosting; it omits model, infrastructure, storage, and maintenance costs or resource tradeoffs.
Installation, cleanup behavior, workflow permissions, licensing, and vulnerability reporting are traceable to specific supplied files. The license claim is corroborated by LICENSE, and parts of the security posture are corroborated by SECURITY.md and the CodeQL workflow. Core claims about the vault, credential isolation, deployment breadth, publishing, and model routing appear only in the README without supporting code, configuration, or tests. The README does not consistently distinguish implemented repository facts, hosted-service features, design goals, and promotional assertions, so fact-versus-inference separation is limited.
- Do not connect production credentials based solely on the README's secure-vault and hidden-key claims; inspect the actual vault implementation, outbound data paths, logging, and retention first.
- Publishing URLs, connecting external systems, and scheduling operations can create external effects, but the supplied files do not demonstrate per-action confirmation, approval, or reversal controls.
- make flush removes conversations, keys, databases, and project state under ~/.anton and ~/.cowork; verify backups before use, and do not treat software reinstallation as data recovery.
- Repository identity, clone target, product names, and the security version series are inconsistent; confirm the submodule commits, applicable documentation, and supported scope for this revision before deployment.
- The CodeQL workflow covers detected Actions and Python files in the checked-out superproject; it does not establish that every pinned submodule or desktop dependency is scanned.
What does this agent do, and when should you use it?
MindsHub Cowork is a workspace for delegating complete projects such as applications, websites, research, analysis, reports, and scheduled operations. The repository is a platform superproject that pins together the desktop and web application, agent backend, and data engine as submodules. Users can connect systems including BigQuery, Postgres, Gmail, Drive, HubSpot, Notion, and Linear, then route work through Claude, GPT, Gemini, DeepSeek, Qwen, or Kimi. Anton and Hermes are interchangeable open-source agent harnesses, while outputs can become documents, dashboards, applications, or code published at a live URL. The platform also supplies cross-session memory, reusable skills, and scheduling, with hosted, local, VPC, on-premises, air-gapped, and hybrid deployment options.
A user first links a supported data system such as BigQuery, Postgres, Gmail, Drive, HubSpot, Notion, or Linear through the secure vault; credentials remain scoped to each connection and agents do not receive raw keys. The Model Router then sends work to a selected Claude, GPT, Gemini, DeepSeek, Qwen, or Kimi model, while the agent harness can be switched between Anton and Hermes from a dropdown. The agent performs multi-step reading and writing work, including research, reporting, monitoring, analysis, and recurring operations. Its results can be turned into documents, dashboards, applications, and code, then published at a shareable live URL. Memory persists context across sessions, skills package reusable behavior, and scheduling repeats tasks; source-based execution is exposed through commands such as make dev, make dev-web, and make build.
- An operations team that repeatedly assembles business updates can connect its existing systems and schedule monitoring, reports, and recurring workflows.
- A strategist or business user without a dedicated engineering team can build an internal dashboard, presentation, document, analysis, or application and publish it for colleagues.
- A team evaluating different model families can switch among Claude, GPT, Gemini, DeepSeek, Qwen, and Kimi without rebuilding the surrounding workspace and artifacts.
- An organization with data-residency or infrastructure-control requirements can run the stack in a VPC, on premises, in an air-gapped environment, or as a hybrid deployment.
- A developer can run the Electron desktop application or web SPA from the superproject and work on feature branches inside its pinned submodules.
What are this agent's strengths and limitations?
- The Model Router covers both frontier and open model families without requiring users to wire a separate key for every provider.
- Data connections, agent execution, memory, reusable skills, scheduling, artifact creation, and live publishing are combined in one workspace.
- Anton and Hermes are interchangeable open-source harnesses rather than a single fixed agent runtime.
- Delivery options span a hosted web app, macOS and Windows desktop packages, local execution, VPC, on-premises, air-gapped, and hybrid deployments.
- Connection-scoped credentials keep raw keys hidden from agents.
- The superproject uses multiple pinned submodules, so contributors must manage
dev.env, module branches, baselines, and deliberate pin updates. - No prebuilt Linux package is documented; Linux adopters must build from source.
- All frontier models and private artifacts require Pro, while the supplied material does not state prices or free-tier limits.
- External data connections and hosted models depend on network access and third-party availability, and detailed connector authentication is not provided here.
make flushdeletes conversations, saved keys, database state, Hermes data, and projects, creating a significant local data-loss risk if used carelessly.- The supplied repository identifier is
mindsdb/mindshub, while README clone commands, badges, and issue links point tomindsdb/minds; adopters should verify the canonical repository before automating installation.
How do you install or deploy this agent?
For a hosted start, open https://console.mindshub.ai/ and sign in. macOS users can install the provided .pkg, and Windows users can install the provided .exe; Linux users must build from source. The documented source setup is:
git clone --recurse-submodules https://github.com/mindsdb/minds.git
cd minds
make setupThe repository advertises Python 3.10–3.13 support. Run make dev or make watch for the Electron desktop application with hot reload, make dev-web for the browser SPA, or make build for a production build. The supplied material does not enumerate every underlying build dependency or the exact authentication fields required by each external connection.
How do you use this agent?
The shortest path is to sign in at https://console.mindshub.ai/, connect the required data systems, select a model and either Anton or Hermes, and delegate a project such as research, reporting, application creation, or a scheduled operation. From source, run make setup, then use make dev for the hot-reloading Electron application or make dev-web for the browser interface. For submodule feature work, run cp dev.env.example dev.env, set REF=feat/my-thing or module-specific references, and run make use before starting the application. Use make refs to inspect the selected references, make baseline to restore pinned commits, and make pin when intentionally updating the superproject pins. Treat make flush as destructive: it removes local runtimes and state under ~/.anton and ~/.cowork, including conversations, saved keys, the database, Hermes data, and projects.
How does this agent compare with similar options?
At the harness level, Anton is the default and Hermes is the documented interchangeable option, but the supplied material does not establish a feature or performance difference between them. At the model level, the Model Router spans frontier choices—Claude, GPT, and Gemini—and open choices—DeepSeek, Qwen, and Kimi—so the stated distinction is replaceability rather than a single preferred provider. For delivery, the hosted web app minimizes installation, whereas local, VPC, on-premises, air-gapped, and hybrid deployments provide more infrastructure and data control at the cost of self-managed building and operations.
FAQ
Can I start for free?
Can agents see the raw credentials for connected systems?
Am I locked to one model or agent harness?
Can the complete stack run on infrastructure I control?
How do I recover from a broken local installation?
make flush clears the local runtime and application state so the next make setup or application launch can reinstall it. It also deletes conversations, saved provider keys, database state, Hermes data, and projects; FORCE=1 skips its confirmation prompt, so important state should be backed up first.