OpenLoaf

Open-Source AI Productivity Desktop — Project-Centric, Multi-Agent, Local-First

Each project gets its own AI agent team, memory, and skills. Projects link to share knowledge. A Secretary Agent orchestrates everything. The agent runtime, memory system, skills loading, and tool routing are native OpenLoaf capabilities - not a thin wrapper around Claude Code. Your data never leaves your device.

💬 AI Secretary  |  📁 Independent Projects  |  🔗 Project Linking  |  🤖 Multi-Agent  |  🎨 Canvas  |  📧 Email  |  📅 Calendar  |  📋 Tasks

One app, multiple project windows. Each project has its own AI team. Link projects to share knowledge. A Secretary Agent ties it all together — 100% local.

📥 Download for macOS / Windows / Linux

English | 简体中文 | 日本語

⚠️ This project is in active development. Features and APIs may change — use in production with caution. Encountered a bug or have an idea? Submit feedback via the app's built-in feedback button.

OpenLoaf is a local-first AI productivity desktop app built around projects as independent workspaces. Each project opens in its own dedicated window with a full-featured environment: AI assistant, file tree, terminal, task board, and canvas.

A Secretary Agent lives in the main window as your personal assistant — it can answer questions, manage your calendar and email, and route complex tasks to the right project's AI agent. For cross-project work, projects link to each other to share memory and skills.

Built natively into OpenLoaf: the Secretary / Project / Worker agent system, project memory injection, skills discovery, runtime tool execution, and multi-window orchestration are all part of OpenLoaf's own product architecture - not a Claude Code reskin or thin wrapper.

You (the Boss)
  │
  ▼
Secretary Agent (Main Window — your personal assistant)
  │
  ├── Simple tasks → handles directly
  ├── Single-project tasks → spawns a Project Agent
  └── Cross-project tasks → spawns multiple Project Agents in parallel
        │
        └── Project Agent (Project Window)
              │
              └── Worker Agents (explore, plan, code...)

Main Window — your command center:

• AI Secretary for global tasks (calendar, email, cross-project queries)
• Activity timeline showing recent projects, conversations, and canvases
• Project grid to browse and open projects

Project Window — each project gets its own:

• Dedicated AI assistant with project-specific memory and skills
• File explorer, terminal, task board, canvas
• Links to other projects (their memory and skills are auto-injected)

OpenLoaf's AI isn't a single chatbot — it's a layered agent system modeled after how companies work and built specifically for OpenLoaf's project-centric workflow:

The Secretary decides the most efficient path — simple questions get answered immediately, project-specific tasks get routed to the right Project Agent, and complex multi-project tasks spawn parallel agents. Agent roles, project routing, memory injection, skills loading, MCP access, and runtime tool execution are first-class OpenLoaf capabilities rather than a thin layer on top of Claude Code.

Each project opens in its own window (Electron) or browser tab (web). No context switching — work on multiple projects simultaneously with full isolation.

Projects are organized by user-defined type labels (e.g., "code", "docs", "knowledge base") which serve as visual groupings in the project grid. Types are just labels — the system treats all projects equally.

Any project can link to any other project. When linked:

• The linked project's memory is injected into the current project's AI context
• The linked project's skills become available to the current project's agent
• Perfect for sharing a knowledge base, design system docs, or coding standards across multiple projects

Three-level memory hierarchy:

Skills follow the same pattern — global skills plus project-specific skills, all discoverable by AI agents at runtime.

Skills are reusable Markdown workflows defined by a SKILL.md file. Put them in ~/.agents/skills/ for global reuse or in <projectPath>/.agents/skills/ for project-specific behavior, and agents can load the instructions plus related tool dependencies on demand.

OpenLoaf also supports MCP (Model Context Protocol) servers. You can connect external tools over stdio, http, or sse, configure them globally in ~/.openloaf/mcp-servers.json or per project in <projectPath>/.openloaf/mcp-servers.json, and import JSON configs from clients like Claude Desktop, Cursor, VS Code, Cline, or Windsurf to expose GitHub, databases, filesystems, Slack, and more to your agents.

Multi-model AI chat supporting OpenAI, Anthropic Claude, Google Gemini, DeepSeek, Qwen, xAI Grok, and local models via Ollama. AI is aware of your project's full context — file structure, document content, conversation history. Built-in memory lets AI retain knowledge across conversations.

A ReactFlow-based infinite canvas for visual thinking. Supports sticky notes, images, videos, freehand drawing, AI image generation, AI video generation, and image content understanding. Mind maps, flowcharts, and inspiration boards on a single canvas.

Everything in one app — no more window-switching:

• Terminal — Full terminal emulator. AI agents can run commands with your approval.
• Email — Multi-account IMAP email with AI-powered drafting and summarization.
• Calendar — Native system calendar sync (macOS / Google Calendar). AI-powered scheduling.
• File Manager — Grid/list/column views, drag-and-drop, file preview (images, PDFs, Office, code).
• Task Board — Kanban board (To Do → In Progress → Review → Done) with priority labels and AI-powered task creation.
• Rich Text Editor — Block editor built on Plate.js with LaTeX, tables, code blocks, and bi-directional links.

• Software Development — Each repo is a project. Link a shared "coding standards" project for consistent AI behavior across all repos.
• Research & Writing — Create a "references" project as a knowledge base, link it to your paper projects. AI draws from your curated sources.
• Content Creation — Brainstorm on the canvas, generate images with AI, write in the editor, track deliverables on the task board.
• Project Management — One project per client. Secretary Agent gives you a cross-project overview. Calendar and email keep everything coordinated.
• Personal Knowledge Base — Accumulate notes, web clippings, and journal entries. Link to work projects so AI connects the dots.

• Fragmented AI workflows — One thing done requires jumping between five windows.
• No project context — AI forgets everything between conversations. You re-explain your project every time.
• Single-project silos — Projects can't share knowledge. Your coding standards project can't help your code repos.
• Cloud lock-in — Your data lives on someone else's servers. You can't choose your own AI models.

• Self-developed agent stack — The Secretary / Project / Worker architecture, memory pipeline, skills system, MCP integration, and tool runtime are built natively in OpenLoaf instead of being a Claude Code reskin or wrapper.
• Project-centric — Each project is a self-contained environment with its own AI agent, memory, and skills.
• Linked knowledge — Projects share context through explicit links. A knowledge base enriches every project it's linked to.
• Multi-agent routing — The Secretary Agent handles the orchestration. Simple tasks are fast; complex tasks get the right specialist.
• Local-first — All data stored locally (~/.openloaf/). Bring your own API keys. No telemetry, no tracking.
• Ready out of the box — Download, install, go. No servers, databases, or Docker.

OpenLoaf's logo is a bread-shaped sofa. Loaf means both "bread" and "to lounge around" — hand off tedious work to AI while you make the important decisions.

• 100% Local Storage — All data stored on your filesystem (~/.openloaf/). Nothing uploaded to cloud servers.
• Bring Your Own Key (BYOK) — Configure your own AI API keys. API calls go directly from your device to the model provider.
• Works Offline — Core features work fully offline. Use Ollama for a completely air-gapped AI experience.
• No Telemetry — No analytics, no usage data, no tracking. What happens on your device stays on your device.
• Open-Source & Auditable — Full codebase under AGPLv3. Inspect every line that touches your data.

• Node.js >= 20
• pnpm >= 10 (corepack enable)

# Clone the repository
git clone https://github.com/OpenLoaf/OpenLoaf.git
cd OpenLoaf

# Install dependencies
pnpm install

# Initialize the database
pnpm run db:migrate

# Start the development environment (Web + Server)
pnpm run dev

Open http://localhost:3001. For the desktop app: pnpm run desktop.

┌────────────────────────────────────────────────────┐
│                    OpenLoaf                          │
│                                                      │
│  Main Window                                         │
│  ├── Secretary Agent (global AI assistant)           │
│  ├── Activity Timeline (recent history)              │
│  ├── Project Grid (all projects by type)             │
│  ├── Calendar, Email, Canvas (global features)       │
│  └── Settings                                        │
│                                                      │
│  Project Window (one per project)                    │
│  ├── Project Agent (project-scoped AI)               │
│  ├── File Tree, Terminal, Search                     │
│  ├── Task Board, Canvas                              │
│  ├── Linked Projects (shared memory/skills)          │
│  └── Project Settings & Skills                       │
│                                                      │
│  Data Layer                                          │
│  ├── ~/.openloaf/memory/          (user memory)      │
│  ├── ~/.openloaf/config.json      (project registry) │
│  ├── ~/.openloaf/openloaf.db      (SQLite database)  │
│  ├── <project>/.openloaf/memory/  (project memory)   │
│  └── <project>/.agents/skills/    (project skills)   │
└──────────────────────────────────────────────────────┘

apps/
  web/          — Next.js 16 frontend (static export, React 19)
  server/       — Hono backend, tRPC API
  desktop/      — Electron 40 desktop shell
packages/
  api/          — tRPC router types & shared API logic
  db/           — Prisma 7 database schema (SQLite)
  ui/           — shadcn/ui component library
  config/       — Shared env utilities & path resolution

• Multi-agent architecture (Secretary → Project Agent → Workers)
• Independent project windows
• Project linking with shared memory/skills
• User-defined project types with visual grouping
• Activity timeline in main window
• Full web browser access (without desktop app)
• Internationalization (i18n) — in progress
• Project template marketplace
• WPS / Microsoft Office integration
• More features coming...

1. Fork this repository
2. Create your feature branch: git checkout -b feature/my-feature
3. Commit your changes (Conventional Commits):

   git commit -m "feat(web): add dark mode toggle"

4. Push: git push origin feature/my-feature
5. Open a Pull Request

Before submitting a PR, please read the Contributing Guide and Development Guide, and sign the CLA.

OpenLoaf uses dual licensing:

• Open Source — GNU AGPLv3: Free to use, modify, and distribute. Derivative works must remain open-source.
• Commercial — For closed-source commercial use, contact us for a commercial license.