LazyMind
An AI Skill Runtime that turns knowledge, expert practice and tools into executable, recoverable tasks you control.
- Source repo
- LazyAGI/LazyMind
- Stars
- ★ 433
- Last updated
- today
- License
- Apache-2.0
- Primary language
- Go
- FA score
- 50/100 · Major gaps
At a glance
- How it runs
- Works with
- Portable with changesCodexChatGPT (Needs adaptation)
- Cost
- Free software; you pay for model usage
- Setup effort
- Medium · a few setup steps
- You'll need
- Typical use
- A solution architect or PM needs to move a rough idea to a proposal, PRD and prototype by chaining competitor analysis, product planning and requirements drafting.
- Not a fit if
- Non-technical users who want zero configuration and no model or parsing setup
- Teams that only want a hosted SaaS with nothing to install
- Source review
- 50/100 · Major gaps
What does this agent do, and when should you use it?
LazyMind is an AI Skill Runtime for knowledge-intensive work, packaging knowledge bases, expert methods, tools and editable artifacts into a single workspace. Three systems carry it: the Knowledge Foundation ingests from local folders, object storage, Feishu and Notion and runs OCR, hybrid retrieval and reranking; the State Brain executes Workflows as state machines with visible steps, approvals, retries, rewinds and version history; the AI Growth Engine captures preferences and validates changes through evaluation, diagnosis, repair and A/B tests. You can run it as a Desktop Mode app on macOS arm64 or Windows x64, or deploy it as a containerized team service on port 8090. Outputs leave the runtime as editable documents, PDFs, image-based or editable PPTX files and images, and external agents such as Codex, Cursor, WorkBuddy, TRAE Work and DeepSeek Harness can drive it through Settings → Assistants and MCP. The project is Apache-2.0 licensed and brings no models of its own.
LazyMind ingests documents from local directories, object storage, Feishu, Notion and other sources, parses them with PDFReader, MinerU or PaddleOCR-VL, then serves answers through multi-embedding retrieval, hybrid search and reranking with inline citations and source navigation. Task execution lives in backend/core, which runs Skills converted into Workflow state machines with dynamic routing, automatic review, retry and rewind; intermediate artifacts stay inspectable and editable, with version diffs. Built-in content Skills include AI Writer, the PPT Workflow and AI Image — the PPT workflow gathers material, gates on an outline, generates slides, accepts natural-language edits on selected elements and exports PDF, image PPTX or fully editable PPTX. The evo module turns bad cases into evaluation samples and runs baseline evaluation, diagnosis, repair, deployment and A/B testing. A host-side Assistant Bridge discovers local Codex, Cursor and similar projects and continues their sessions, while MCP exposes LazyMind Workflows, Skills and knowledge bases to outside agents.
- A solution architect or PM needs to move a rough idea to a proposal, PRD and prototype by chaining competitor analysis, product planning and requirements drafting.
- A consultant or analyst must deliver a defensible report whose claims trace back to internal documents and web sources with inline citations.
- A content team needs repeatable deck production: submit a request, approve the outline, then edit individual slides and export PPTX with speaker notes.
- A team already running Codex, Cursor or DeepSeek Harness wants those assistants to call shared knowledge bases, Skills and Workflows instead of rebuilding context each time.
- A QA or ops owner wants quality changes gated by evidence: convert a bad case into an evaluation sample, diagnose, A/B test, then deploy.
- A reader working through a PDF wants to select a passage and ask about it, keeping the answer anchored to the selection and the original page.
How do you install or deploy this agent?
The recommended local path is the desktop installer from GitHub Releases:
# macOS (Apple silicon): download the .dmg, open it and drag LazyMind into Applications
# Windows x64: download and run the .exe installerThe installers bundle the local runtime Desktop Mode needs. To run from source you need Go, Python 3, uv, pnpm and Node.js:
make local-upOn native Windows PowerShell use:
make local-win-upFor container deployment (Docker services plus the host-side Assistant Bridge):
make upIf Docker is present but Go is not, the bridge is cross-compiled inside Docker automatically. On Windows run this from Git Bash with make available; plain docker compose up cannot reach host-installed programs. To point at external vector and search services:
make up LAZYMIND_MILVUS_URI=http://your-milvus:19530 LAZYMIND_OPENSEARCH_URI=https://your-opensearch:9200Optional on-premises OCR can be added with make up LAZYMIND_DEPLOY_MINERU=1 or make up LAZYMIND_DEPLOY_PADDLEOCR=1.
How do you use this agent?
After startup, open http://localhost:8090 (API docs at /docs.html) and log in with the default admin / admin. Configure models and tools first:
Settings → Model Providers: add provider credentials and API keys
Settings → System Defaults: pick the default LLM, embedding and reranker (multimodal embedding, VLM, speech, image, video and evolution models are optional)
Settings → Tools: configure MinerU or PaddleOCR for parsing, web and academic search engines, and Feishu/Notion credentialsThen submit work in Chat or Work, browse the Capability Center to filter ready-to-run Skills by scenario and launch a template, or open a PDF and select text for a document-scoped conversation. To hand LazyMind to an external agent:
Settings → Assistants: connect Codex, Cursor, WorkBuddy, Raccoon, TRAE Work or DeepSeek Harness (supply a custom or portable path if auto-discovery fails)Stop the local runtime with:
make local-downOn Windows use make local-win-down. Development checks are make lint, make test and make test-hermetic; to package the desktop app from source use make desktop-darwin-arm64, make desktop-windows-x64 or make desktop-windows-x64-installer.
What are this agent's strengths and limitations?
- Workflows are explicit state machines with dynamic routing, automatic review, retry and rewind, so a failed long task resumes from the broken step rather than restarting.
- A complete retrieval stack — multi-source ingestion, PDFReader/MinerU/PaddleOCR-VL parsing, embedding plus hybrid search and reranking — with inline citations and source navigation.
- Artifacts stay editable with version diffs, and the PPT workflow supports thumbnail reordering, natural-language edits on selected elements, and export to editable PPTX.
- Local-first design: the desktop build ships its own runtime using SQLite and Milvus Lite, while the same workflows scale to a container deployment with Kong and JWT/RBAC.
- MCP plus the Assistant Bridge let Codex, Cursor, DeepSeek Harness and others reuse LazyMind knowledge, Skills and Workflows instead of duplicating setup.
- Improvements are evidence-gated: evo turns bad cases into evaluation samples and runs baseline evaluation, diagnosis, repair and A/B tests before rollout.
- You must supply model provider keys and choose default LLM, embedding and reranker; first-run quality depends on external services you configure yourself.
- Source builds require Go, Python 3, uv, pnpm and Node.js together, and container deployment adds the host-side bridge as a separate moving part.
- Desktop installers are documented only for macOS arm64 and Windows x64; no Linux desktop build appears in the docs.
- Several advertised capabilities — Skill compatibility scoring, on-demand Skill retrieval, authorized local folders, external-agent permission audit — are still on the roadmap.
- Most demo videos and articles are in Chinese, which limits how English-speaking evaluators can judge output quality before installing.
How does this agent compare with similar options?
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| LazyMind This agent | 50 · Major gaps | Desktop appFree + model costs | ★ 433 | today | Go | Codex |
| NextClaw | 58 · Major gaps | Desktop appFree + model costs | ★ 262 | today | TypeScript | Codex · Claude Code |
| PocketPaw | 46 · Major gaps | Desktop appFree + model costs | ★ 895 | 1mo ago | Python | Codex · OpenAI API · Claude API |
| OpenKB | 59 · Major gaps | CLIFree + model costs | ★ 4.8k | 3mo ago | Python | Codex · Claude Code · OpenAI API · Claude API |
How does FollowAgents rate this agent?
Why each dimension lost points
The workspace file-authorization doc details ALLOW/ASK/DENY policy, always_ask default, path-identity checks and non-persistence of credentials; the MCP OAuth doc states tokens stay in the auth service, are not cached across requests, and private destinations are rejected, so least_privilege and user_confirmation score 2. Data-flow transparency is documentation-only with no user-facing runtime data-flow view or audit export, deducted to 1. Dependency security relies on pinned versions and lockfiles but shows no vulnerability scanning or SBOM, and depends on a LazyLLM submodule gitlink and mcp<2 constraint, so 1. External effects (browser automation, shell, email sending) are gated by approvals but the default capability surface is broad with no consolidated side-effect inventory, so 1. Rollback is well described for artifacts, skills and migration up/down, so 2. Source attribution cites external videos/articles but third-party components and data sources are not systematically attributed, so 1.
The docs contradict themselves: README calls the capability list implemented rather than roadmap, yet the Roadmap lists many unfinished items; the tool-configuration doc records 30 failing Chat tests, 648 frontend tsc errors and no real OAuth end-to-end run, so self_consistency is 1. Dependency availability depends on the LazyLLM submodule, ModelScope/HuggingFace remote assets, ripgrep and Docker; fallback and checksum verification are documented but build environments are not fully locked, so 1. Failure messages are handled: sanitized reauthorization notices, expired vs inactive distinction, blockers excluded from retry, so 2.
README clearly separates Desktop users, team deployment and external-agent plugin scenarios, so 2. Capability boundaries are documented (no OAuth over SSE, no pre-registered clients, Windows NTFS/ReFS only, Linux no cross-remount guarantee), so 2. Trigger precision is weak: Skill/Workflow triggering and on-demand tool retrieval remain roadmap items with no verifiable trigger definition, so 1. Environment fit covers macOS arm64, Windows x64 and Linux containers with a multi-OS CI matrix, so 2.
README is well structured, bilingual and clearly navigable, so information_architecture 2. Install notes cover installers, source, containers and desktop builds, so 2. Naming stability is weak: version references (v0.2 article, 0.4 roadmap) mix with branch/commit references and product names (LazyMind/LazyLLM/evo) are inconsistent, so 1. Examples and FAQ are extensive with case directories and videos, so 2. Known limitations are thoroughly recorded in development docs, so 2. LICENSE is full Apache-2.0, so 2. Versioning/changelog is only scattered release articles with no formal CHANGELOG, so 1. Maintenance responsibility is unclear: publisher is unverified and no maintainer, support channel or security-disclosure process is stated, so 1.
Output usability is concrete: editable artifacts, version diffs, PPTX/PDF export, so 2. Marginal value is hard to confirm statically: the feature surface is very broad (knowledge base, workflows, skills, self-evolution, browser automation) but much is roadmap or not end-to-end verified, so 1. Cost-benefit: ~448 MiB installer plus separate RAG component and model API costs, with startup-time and memory gains explicitly unmeasured, so 1.
claim_traceability: README capability claims point to docs and screenshots, but screenshots/videos are externally hosted and not verifiable within the repository, so 1. cross_source_corroboration: development docs partly corroborate README (MCP OAuth, installer optimization) but also conflict where README claims implemented features that dev docs record as failing or unverified, so 1. fact_inference_separation: development docs explicitly separate verified, unverified and inferred results (e.g. stating the comparison is not a strict A/B and not equal total-traffic reduction), so 2.
- Publisher identity is unverified by the FollowAgents registry; maintenance responsibility, support channels and security-disclosure process are unclear, so enterprises should verify independently.
- Development docs explicitly record 30 failing Chat tests, 648 frontend typecheck errors, and no real OAuth or browser end-to-end run; README's 'implemented capabilities' claims should be treated cautiously.
- Default admin/admin credentials and local service binding must be changed before deployment to avoid unauthorized access.
- The desktop app has browser automation, shell and file-write capabilities; even with always_ask defaults, the conditions enabling fully-trusted allow_all mode should be reviewed.
- The installer is ~448 MiB and RAG components, fonts and sample assets are downloaded from ModelScope/HuggingFace; offline or restricted-network availability is unverified.
- No dependency vulnerability scanning or SBOM is evident; supply-chain risk from the LazyLLM submodule and mcp<2 constraint should be assessed independently.