LazyAGI/LazyMind

中文 | English

LazyMind: Keep AI-Agent under your control.

LazyMind is an AI Skill Runtime for knowledge-intensive work: an environment that turns knowledge, expert practice, and tools into executable, recoverable tasks. It connects reusable knowledge, executable Skills, observable workflows, editable artifacts, and evaluation-driven improvement in one workspace.

Instead of repeatedly uploading context, tuning prompts, and supervising every agent step, you choose the knowledge and workflow once. LazyMind then plans, executes, exposes intermediate results, and carries accepted feedback into the next run. Use it locally in Desktop Mode, deploy it as a shared enterprise service, or provide knowledge, Skills, and Workflows to external agents such as Codex, Cursor, and WorkBuddy.

• Desktop Mode is designed for technically capable professionals whose primary job is not programming, including solution architects, product managers, operators, testers, and content creators.
• Team and enterprise deployments serve secondary development, project delivery, proposals, FDE work, and organization-wide knowledge collaboration with shared permissions, deployment, and evaluation capabilities.

Quick start · Showcase · Example directory · Product architecture · Build a workflow · Desktop mode

See the Codex integration and DeepSeek Harness integration for implementation details.

For an end-to-end product video, see the Chinese README.

See LazyMind in action through published demos. All videos and articles below are in Chinese; links open on their original platforms.

• Refining AI presentation layouts and content (Bilibili) · Case notes
• Creating your own animated stickers (WeChat Channels) · Case notes
• Bringing AI agents into your workflow (WeChat Channels) · Case notes

• LazyMind v0.2: from answers to deliverables (2026-08-04, release introduction)
• Why are you still working overtime after AI finishes? (2026-09-01, product introduction)

flowchart LR
    K["Knowledge<br/>local files · cloud docs · object storage"] --> R["Retrieve & reason<br/>parse · OCR · hybrid search · rerank"]
    S["Skills & workflows<br/>instructions · tools · state machines"] --> X["Observable execution<br/>steps · approvals · retry · rewind"]
    R --> X
    X --> A["Editable artifacts<br/>citations · revisions · delivery"]
    A --> F["Feedback & evaluation<br/>preferences · bad cases · A/B tests"]
    F --> K
    F --> S

This loop is built from three connected systems:

Choose knowledge and a Skill; LazyMind continues from source organization through planning, generation, review, and delivery. Workflows define steps, tools, inputs, outputs, and transitions as state machines, while artifacts preserve editable results and revision history.

For long-running work, each step remains visible. Users can approve checkpoints, edit an artifact, or rerun from the failed step instead of restarting the whole task.

Inspect and edit the Artifact before continuing

Review a version diff and restore the result you need

Local directories, object storage, Feishu, Notion, and other sources feed a unified knowledge base. PDFReader, MinerU, or PaddleOCR-VL parses documents; multi-embedding retrieval, hybrid search, and reranking keep results grounded in relevant evidence.

Organize documents and track parsing status in one knowledge base

Ground answers with inline citations and traceable references

Research methods, writing processes, and domain standards can be managed as Skills and converted into executable Workflows. Teams can diagnose, repair, publish, version, and roll them back instead of rebuilding the same setup from prompts and scripts. See the Workflow format specification.

Select a Skill as the source of a new workflow

Inspect, refine, publish, and version the generated workflow

The PPT Workflow carries a presentation request through research, outline approval, slide generation, review, and export. It can use the user's prompt, uploaded files, LazyMind knowledge bases, web search results, and AI-generated images as source material, and it produces speaker notes for each slide.

Intermediate results, including collected materials and the outline, remain visible and editable throughout generation. After generation, users can drag the left thumbnails to reorder slides, remove slides and select text or elements for natural-language content and style changes. Results can be exported as PDF, image-based PPTX, or editable PPTX containing text, shapes, images, and charts.

Gather material from the web, generate slides, and drag the left thumbnails to reorder pages	Inspect and edit intermediate results, including the outline, throughout generation
Select slide content and describe changes in natural language	Export as PDF, image-based PPTX, or editable PPTX

The Capability Center brings quick chat, complex tasks, and curated examples into one entry point. Users can filter by scenario, capability type, and technical tags; inspect the description, workflow, example input, and interactive result; then launch the capability in Chat or Work. Curated entries are backed by runnable Skills and installed on demand when first used.

Search and filter ready-to-run capabilities by scenario and goal	Explore an example’s execution steps and output, then select Try it
Load the example’s task template, add your own requirements and references, and start
Follow execution and compare the reference image with generated stickers and downloadable outputs

The document preview supports conversations scoped to the current document and can cite PDF selections, knowledge chunks, or partial chunk content. Temporary document conversations stay out of normal chat history unless the user chooses to promote and save them.

Select text in a PDF and ask a question in the document conversation

Read the answer alongside the PDF and save the conversation to Chat when needed

LazyMind can discover local projects and native task histories from Codex, Cursor, WorkBuddy, TRAE Work, DeepSeek Harness, and other agents, then create, continue, and inspect their work in one workspace. Through MCP, external agents can also use LazyMind Workflows, Skills, knowledge bases, and cloud documents without rebuilding the same task context.

Codex controls LazyMind to generate images and displays the workflow result	Codex follows a LazyMind Workflow to generate and return an image artifact
Open an embedded LazyMind Workflow in Codex to inspect and review intermediate results	Display a LazyMind Workflow in DeepSeek Harness to review slides and speaker notes

Knowledge Ops captures what the user wants—preferences, terminology, experience, and Skills. evo tests how the system should improve by turning bad cases into evaluation samples and running baseline evaluation, diagnosis, repair, and A/B testing.

Knowledge Ops reviews Skills, preferences, terminology, and experience

Algorithm evolution validates improvements before rollout

Desktop Mode uses native processes, SQLite, and Milvus Lite with platform-standard data paths. Shared deployments add Kong, JWT/RBAC, Core ACL, external Milvus/OpenSearch, and on-premises OCR. Your workflow stays recognizable across both modes.

Local runtime: SQLite databases and state storage, with services bound to localhost

Container deployment: Kong with RBAC, an authentication service, and persistent PostgreSQL storage

Download the latest installer from GitHub Releases:

• macOS (Apple silicon): download the .dmg, open it, and drag LazyMind into Applications.
• Windows x64: download and run the installer .exe.

The installers include the local runtime needed for Desktop Mode. For normal local use, install the .dmg or .exe instead of building and packaging LazyMind from source.

Prerequisites: Go, Python 3, uv, pnpm, and Node.js.

make local-up

On native Windows PowerShell:

make local-win-up

After startup:

• LazyMind: http://localhost:8090
• API docs: http://localhost:8090/docs.html
• Default credentials: admin / admin

After login, open Settings in the frontend:

• Add provider credentials and API keys under Model Providers, then select the default LLM, embedding, and reranker under System Defaults. Multimodal embedding, VLM, speech, image, video, and evolution models are optional.
• Configure service credentials under Tools when needed, including MinerU or PaddleOCR for document parsing, web and academic search engines, and other integrations. No environment variable is required for a hosted MinerU API key.

Select the default models for each system capability

Configure document parsing, search, and integration credentials

Stop the local runtime with:

make local-down

Use make local-win-down on Windows. See the Quick Start guide for complete configuration.

The commands below are intended for development and release packaging. Local users should normally use the installers above.

make up

This starts both the Docker services and the host-side Assistant Bridge. Open Settings → Assistants to connect Codex, Cursor, WorkBuddy, Raccoon, TRAE Work, or DeepSeek Harness without running separate MCP configuration commands. If Docker is installed but Go is not, the bridge is cross-compiled for the host automatically inside Docker.

On Windows, run this command from Git Bash with make available. Do not replace it with bare docker compose up: containers cannot inspect or launch programs installed on the Windows host. On macOS and Windows, the host bridge discovers CLIs and desktop applications through the operating system; Settings → Assistants also accepts a custom or portable host path when automatic discovery cannot resolve it.

See the Colima setup guide or the complete Quick Start guide. The Architecture guide covers service dependencies, environment variables, and the authentication chain.

This table describes capabilities implemented in the repository today, not a future roadmap. See docs for module design and implementation details.

LazyMind's next phase is not about adding more isolated features. The goal is to strengthen the Skill Runtime so knowledge, Skills, Workflows, and self-evolution form complete task loops both inside LazyMind and across other agents.

Skill Runtime and Desktop

• Popular Skill compatibility and evaluation: measure installability, safety, core-flow completion, and output quality so verified Skills run without source changes and failures explain the actual cause.
• Curated Skill scale-up: expand verified official Skills and reproducible demos across representative industries and tasks, using quality results as a recommendation signal.
• Skill → Workflow experience: add preflight checks, progress and failure diagnosis, task recovery, and explicit association with the original Skill; let users choose either execution path.
• On-demand Skill and Tool retrieval: retrieve only the capabilities relevant to a task and load full definitions after a match to reduce context and token use.
• Trusted local workspace: let Desktop Work users select and authorize local folders, read or write within explicit boundaries, and review or revoke access.
• Browser context: use a Chrome extension, with user authorization, to obtain the current page title, body, links, and basic metadata for complex tasks.
• Onboarding and task preflight: improve model setup, dependency checks, permission guidance, failure recovery, and local-runtime diagnostics for non-developers.

External agent ecosystem

• Complete Workflow invocation: let Codex, Cursor, WorkBuddy, TRAE Work, DeepSeek Harness, and other supported agents submit Skills and tasks, then receive status, result files, and LazyMind task links.
• Unified document access: expose local files, Feishu, Notion, and Google Drive within existing authorization boundaries and return consistent content and source metadata.
• Shared models and tools: proxy authorized models and tools through LazyMind so multiple agents can reuse one configuration without receiving raw API keys.
• Permissions and audit: centrally manage external-agent grants, call status, usage, and execution history.

Task and resource infrastructure

• Unified File Resource: cover attachments, knowledge bases, web results, MCP Resources, and every Artifact type, with on-demand reading for large content.
• Conversation organization: support conversation forks, groups, and retained sub-conversations so exploratory branches remain organized and resumable.
• Artifact delivery: give documents, sheets, images, code, and archives explicit completion, preview, and download states.
• Preference consolidation: merge duplicate or conflicting preferences and remove low-value entries so important preferences continue to reach task context.

Knowledge sources, editing, and publishing

• Long-form sources: connect Obsidian, GitHub Docs/Wiki, and Yuque while improving Notion synchronization, attachments, and write-back.
• Unified content representation: strengthen round-trip conversion among Markdown, Writer IR, and platform rich text, previewing format degradation without silently dropping images, code, or body content.
• Result delivery: improve high-fidelity DOCX and other exports, shareable result pages, and publishing to Feishu, Notion, and WeChat Official Account drafts.
• Multi-channel notification and email: deliver scheduled-task results through Feishu, WeCom, WeChat, and other channels; support email reading, task assistance, and draft generation.
• Scenario packages and team governance: package Workflows, Skills, knowledge, review rules, and output formats together, with dependency, security, version, and organization controls.

Flagship scenario: evidence-driven paper research and technical writing

• Translate, explain, question, collect vocabulary, and save evidence from PDF selections, with navigation back to the original text.
• Expand from one paper to related-paper search, import, multi-paper comparison, and literature review while distinguishing full text, abstracts, and model inference.
• Introduce Evidence between papers and the final document, bind evidence to sections, draft incrementally, and check whether key claims are supported.
• Reuse AI Writer for material analysis, outlining, section drafting, local evidence repair, citation verification, and export with a complete paper list.

Image placeholder: paper reading to technical-guide workflow. Use a horizontal flow or four-panel composition showing PDF selection reading, the paper Evidence list, multi-paper comparison, and citation-grounded writing in AI Writer. Every stage should visibly preserve source information or navigation back to the original text.

• Detect workflow and knowledge gaps from user edits, reruns, citations, and final acceptance signals.
• Continuously evaluate and A/B test retrieval strategies, prompts, models, tools, and Workflow revisions.
• Turn successful execution patterns into reusable Skills, templates, and organizational memory with full provenance and version history.
• Expand across industries through horizontal task templates, vertical knowledge packs, and installable scenario packages instead of rebuilding the product for every industry.

The roadmap will evolve based on real workflow completion rates, output quality, human interventions, latency, and cost. Repository issues, milestones, and release notes remain the source of truth for specific releases.

LazyMind/
├── frontend/                   # Web UI and desktop frontend
├── backend/
│   ├── auth-service/           # Authentication, OAuth, and users
│   ├── core/                   # Data, tasks, retrieval, Workflows, and ACL
│   └── scan-control-plane/     # Source scanning and synchronization
├── algorithm/
│   └── lazymind/               # Chat, parsing, retrieval, and agent runtime
├── workflows/                    # Built-in Workflows
├── skills/                     # Built-in and curated Skills
├── evo/                        # Self-evolution and evaluation loop
├── desktop/                    # Electron desktop application and packaging
├── local/                      # Host-local runtime management
├── api/                        # OpenAPI specifications
├── docs/                       # Architecture, usage, and design docs
└── tests/                      # Cross-service tests

make lint              # Python, Go, docs, and other static checks
make lint-only-diff    # Check changed files only
make test              # Test with host-provided runtimes
make test-hermetic     # Test the same scope in project-managed runtimes

• Python 3.11+
• Go 1.24.0
• Node.js 20
• OpenAPI specifications are maintained under api/

See LICENSE.