LocalAI Cowork

The open-source, local-first AI coworker for Windows and Linux. LocalAI Cowork combines tasks, files, local or hosted models, MCP tools, approvals, and reusable workflows in one inspectable desktop application.

It is an independent open-source alternative for people who like the outcome-driven approach of Claude Cowork and Microsoft Copilot Cowork, but want Ollama support, model choice, and source they can inspect and modify. It is early-stage software—not a claim of feature parity with either commercial product.

LocalAI Cowork is an independent project. It is not affiliated with or endorsed by Anthropic, Microsoft, or the separate LocalAI project.

Website · Download · Report a bug · Request a feature · Security

Most AI work happens in separate browser tabs, terminals, file explorers, and local tools. LocalAI Cowork brings those pieces into a desktop app that can keep context, ask for approval before risky actions, and work with local or self-hosted model providers.

No LocalAI Cowork account is required. Use Ollama for local model execution or connect a compatible provider when a hosted model fits the task better.

The project is early. Windows is the most mature target, while Linux x86_64 is released as a beta-quality AppImage, DEB, and RPM. Start with non-sensitive copies of files and review AI-generated work before relying on it.

• Local desktop app built with Tauri, React, TypeScript, and Rust
• Chat workspace with persistent sessions, message history, and streaming output
• Local Ollama support with health checks, model selection, and configurable timeouts
• Local Codex app-server accounts plus reusable OpenAI-compatible provider profiles
• OpenAI-compatible and OpenRouter profile support
• MCP server management with probing and tool execution
• File and folder context for chat tasks
• Task lifecycle with approval states, progress, and audit events
• Skills, prompt templates, runtime instructions, and reusable workflows
• Terminal, process, memory, insight, and pipeline panels
• CDP developer browser with localhost preview, interaction, annotations, DOM, console, and network inspection
• GitHub workbench for local changes, branches, commits, pull requests, reviews, comments, and merges
• Gated Windows and Linux packages for tagged releases
• Optional local-first distributed mode with durable server runs, Web and Android control surfaces, encrypted project snapshots, and background local daemons
• Linux headless/visible Chromium, virtual desktop and LibreOffice sandboxes, plus outbound-only managed Windows executors for Microsoft Office and Windows desktop automation

LocalAI Cowork remains fully usable as a serverless desktop application. An optional self-hosted control plane adds durable runs that continue when every client is closed; it does not turn the project into an externally operated SaaS and is never required for local work.

The desktop implementation is strongest on Windows. Linux x86_64 packages are built and smoke-tested on Ubuntu 22.04 for a conservative glibc baseline. Server-side Linux runs use hardened Docker sandboxes, Chromium and LibreOffice; actual Word, Excel, PowerPoint and arbitrary Windows desktop automation require a separately licensed managed Windows executor.

The opt-in distributed runtime contains a durable Rust control plane, personal background daemon, Linux Docker workers, managed Windows executors, isolated web entry and thin Android shell while preserving the serverless desktop path. Deploy it through the single-port Compose stack and review the remaining physical release gates before exposing it to untrusted users. Start with the architecture, deployment guide, and explicit implementation-status matrix. The distributed stack is currently suitable for trusted development and pilot networks, not public multi-tenant production.

The server is optional. Connecting a desktop later does not upload private project files automatically, and a Run never changes executor after it starts. For the complete decision tree, component prerequisites and verification steps, read Setup and deployment selection.

• Windows 10 or Windows 11, or a modern x86_64 Linux desktop with WebKitGTK 4.1
• Node.js 22+
• npm 10+
• Rust via rustup
• Python 3.12.10 x64 when building the Windows offline runtime
• Python 3.10–3.13 on Linux when using Crew workflows
• Microsoft WebView2 Runtime on Windows
• Ollama, if you want local model execution

cd app
npm ci
npm run tauri dev

cd app
npm run installer

Source builds create an offline CrewAI runtime from the reviewed, SHA-256-pinned requirements.lock. Update that lock only intentionally with npm run prepare:crew-runtime -- -UpdateLock, review the dependency diff, and then rebuild the installer.

The packaged installer is written to:

dist-installers/LocalAI-Cowork-Setup.exe

The original Tauri NSIS output remains under:

app/src-tauri/target/release/bundle/nsis/

On a Linux host with the Tauri Linux prerequisites installed:

cd app
npm ci
npm run tauri build -- --bundles appimage,deb,rpm

The AppImage is the broadest cross-distribution option. Native DEB and RPM packages are also produced under app/src-tauri/target/release/bundle/. See Linux installation for supported formats, runtime requirements, and current limitations.

The canonical Carbon Signal mark lives in brand/open-workframe.svg. Regenerate the web favicon, social preview, and all Tauri icon sizes from that master:

cd app
npm run brand:assets

LocalAI Cowork defaults to a local Ollama endpoint:

http://localhost:11434

Example local model setup:

ollama serve
ollama pull llama3.1:8b

You can change endpoint, model, timeout, context window, and temperature from the app settings.

The repository includes a local DuckDuckGo web-search MCP server:

Name: duckduckgo-websearch
Command: node
Args: scripts/mcp/duckduckgo-websearch-server.mjs
Tool: search_web

Common environment options:

• DDG_MAX_RESULTS, default 5
• DDG_REGION, default wt-wt
• DDG_SAFESEARCH, default moderate
• DDG_TIMEOUT_MS, default 10000

app/          Shared React UI plus Tauri desktop and web image
agents/       Personal/managed executor agents and local background daemon
clients/      Android Tauri shell
crates/       Shared Rust contracts and headless runtime
server/       Axum control plane, worker and signed Docker runner
deploy/       Single-port Compose, sandboxes, gateway and security policies
contracts/    Versioned generated OpenAPI and JSON Schema artifacts
docs/         Public user, architecture and operations documentation
scripts/      Repository-level validation and acceptance helpers
.github/      CI, release automation, and community templates
site/         Public product website and search metadata

cd app
npm run doctor
npm run lint
npm run typecheck
npm run test:ci
npm run build
npm run build:web
npm run test:web
npm run test:gateway
npm run test:storage-chaos
npm run test:storage-pressure
npm run prepare:local-daemon
npm run test:local-daemon

Rust checks:

cd app/src-tauri
cargo check
cargo test
cargo clippy -- -D warnings

Desktop smoke test:

cd app
npm run smoke:desktop

• Documentation index
• Setup and deployment selection
• Development setup and test matrix
• Ollama configuration
• Linux installation
• Desktop control and computer use
• Developer browser and GitHub workbench
• Distributed architecture
• Server deployment and operations
• Distributed implementation status
• Local daemon
• Personal and managed executors
• Android client

The GitHub Actions workflow in .github/workflows/release.yml builds Windows x64 and Linux x64 packages, then publishes one GitHub Release only after every required job succeeds.

git tag vX.Y.Z
git push origin vX.Y.Z

Release conditions are fail-closed: the tag must be valid v-prefixed SemVer, already exist, match the shared npm/Cargo/Tauri version, and point to a commit contained in main. Windows verification, Linux compilation and package smoke tests, vulnerability audits, updater signatures, and the release environment (including any configured protection rules) must all pass before publication. Stable tags cannot be manually marked as prereleases; prerelease tags use a SemVer suffix such as vX.Y.Z-beta.1.

The release includes a Windows NSIS installer plus Linux AppImage, DEB, and RPM packages. It also contains a cross-platform signed latest.json, CycloneDX SBOM, third-party notices, combined provenance, SHA-256 sums, and GitHub attestations. Update signing is mandatory and uses LOCALAI_COWORK_UPDATER_PRIVATE_KEY plus the optional LOCALAI_COWORK_UPDATER_PRIVATE_KEY_PASSWORD; keep the private key recoverable because installed apps trust it for future releases. Authenticode signing uses the LOCALAI_COWORK_CODESIGN_* secrets (with the legacy OPEN_COWORK_* names accepted during migration). Repositories that explicitly set LOCALAI_COWORK_ALLOW_UNSIGNED_RELEASE=true may publish an unsigned Windows installer only with a prominent warning asset and release notice; incomplete signing configuration still blocks publication.

Contributions are welcome while the project is still taking shape. Start with CONTRIBUTING.md, run the local checks before opening a pull request, and keep changes focused.

LocalAI Cowork is licensed under the Apache License, Version 2.0.

Attribution notices are provided in NOTICE. Warranty and liability limitations are included in Sections 7 and 8 of the Apache License, Version 2.0, with an additional plain-language summary in DISCLAIMER.md.