accomplish-ai/openwork: Open Source AI Desktop Agent for Local Task Automation

Most AI tools today force a choice: send your data to someone else's cloud, or settle for a chatbot that can't actually do anything. Developers who manage sensitive files, work under compliance constraints, or simply prefer keeping data on-device have been poorly served by the wave of SaaS AI assistants. Meanwhile, local LLMs via Ollama and LM Studio have matured significantly—but turning them into actionable desktop automation still requires building custom glue code.

accomplish-ai/openwork (branded as "Coworker") addresses this gap directly. It's an open-source AI desktop agent that runs locally, brings your own API keys or local models, and performs real actions: file management, document creation, and browser automation. With 10,901 GitHub stars, 1,288 forks, and an MIT license, it's gaining traction among developers who want AI assistance without surrendering privacy or paying subscriptions. This article breaks down what it actually does, how it works, and whether it fits your workflow.

What is accomplish-ai/openwork?

accomplish-ai/openwork is an open-source AI desktop agent built primarily in TypeScript and distributed under the MIT License. The project—publicly referred to as "Coworker"—is maintained by Accomplish AI and has seen consistent development through its most recent commit on July 15, 2026.

Technically, it sits at the intersection of several active categories: local-first software, AI agents (systems that perform actions rather than just generating text), and desktop automation. Unlike browser-based AI tools or cloud APIs that require uploading files, Coworker operates as a native application using Electron, with a React^{↗ Bright Coding Blog} UI bundled via Vite. A background daemon process handles task execution by spawning OpenCode children and communicating through the @opencode-ai/sdk.

The project's relevance stems from a specific architectural bet: privacy through locality combined with flexibility through BYO AI. Users supply their own API keys (OpenAI, Anthropic, Google, xAI, and numerous others) or run entirely offline via Ollama or LM Studio. There's no Coworker-hosted backend processing your files, no subscription tier, and no vendor lock-in. This design resonates particularly with developers in regulated industries, security-conscious individuals, and those building personal automation stacks without recurring costs.

The 10,901-star count suggests the project has crossed from niche experiment into broader awareness, though it remains early enough that active contribution is both feasible and welcomed by the maintainers.

Key Features

Local Execution with Scoped Permissions Coworker runs entirely on your machine. You explicitly choose which folders it can access, and files never leave your device. This isn't a cloud service with a "local mode"—the architecture is fundamentally local-first, with API calls going directly from your machine to your chosen provider.

Bring Your Own AI Infrastructure The project supports 15+ model providers: Anthropic (Claude), OpenAI (GPT), Google AI (Gemini), xAI (Grok), DeepSeek, Moonshot AI (Kimi), Z.AI (GLM), MiniMax, Venice.ai, Amazon Bedrock, Azure Foundry, OpenRouter, LiteLLM, plus local execution via Ollama and LM Studio. This breadth matters for developers who already have API access, prefer specific models for cost or capability reasons, or want to run entirely offline.

Action-Oriented, Not Chat-Only Unlike conversational AI interfaces, Coworker performs tasks: sorting and renaming files by content or rules, drafting and rewriting documents, automating browser workflows, and executing custom-defined skills. Every action requires user approval, with visible logs and the ability to stop execution at any point.

Custom Skill System Users can define repeatable workflows and save them as reusable skills. This transforms one-off prompts into structured automation that can be triggered consistently—a middle ground between simple scripting and full RPA platforms.

Cross-Platform Native Builds Prebuilt binaries exist for macOS (Apple Silicon and Intel), Windows 11, and Linux (ARM64 AppImage, x64 AppImage, and x64 .deb). The development stack (Electron + React + Vite) explains this coverage, and the build commands in the repository suggest maintainers actively package for all targets.

Open Source with Permissive Licensing MIT licensing means commercial use, modification, and redistribution are all permitted. The full source is available on GitHub, and the development setup is intentionally minimal: Node.js 20+, pnpm 9+, and a single pnpm install && pnpm dev to run.

Use Cases

1. Intelligent File Organization Developers accumulate downloads, screenshots, project artifacts, and log files that quickly become unmanageable. Coworker can sort, rename, and move files based on content analysis or explicit rules—processing a backlog of unsorted documents into a structured hierarchy without manual drag-and-drop. The content-aware aspect distinguishes it from simple cron-based scripts.

2. Document Drafting and Iteration For technical writers, product managers, or developers creating documentation, Coworker drafts, summarizes, and rewrites documents based on prompts. The local execution means proprietary or pre-release content never transits third-party servers—a common blocker for using cloud AI writing tools in corporate environments.

3. Browser Workflow Automation Research tasks, form entry, and repetitive web interactions can be automated through the browser integration. This extends beyond simple bookmarking or macro recording into AI-guided navigation where the agent makes context-dependent decisions about what to click, fill, or extract.

4. Recurring Report Generation Weekly updates derived from local files and notes, meeting materials compiled from documents and calendar data—these multi-source synthesis tasks are tedious to script manually but well-suited to Coworker's skill system. Once defined, the workflow runs consistently with consistent output formatting.

5. Local-First AI Experimentation For developers exploring AI agent architectures, Coworker provides a concrete reference implementation. The Electron/React/Vite stack, the daemon-based task execution, and the OpenCode integration offer patterns applicable to custom agent projects—particularly the separation between UI and execution layers.

Installation & Setup

The project emphasizes minimal friction. Here's the exact setup process from the repository:

Prerequisites:

• Node.js 20 or higher
• pnpm 9 or higher

Development Installation:

# Clone the repository
git clone https://github.com/accomplish-ai/openwork.git
cd openwork

# Install dependencies
pnpm install

# Start development server
pnpm dev

The pnpm dev command launches the desktop application in development mode. For a clean start that clears all stored data:

pnpm dev:clean

Building for Production:

# Build all workspaces
pnpm build

# Build desktop application only
pnpm build:desktop

# Platform-specific packaging
pnpm -F @coworker/desktop package:win    # Windows installer (x64)
pnpm -F @coworker/desktop package:linux  # Linux artifacts (AppImage + deb)

End-to-End Testing:

pnpm -F @coworker/desktop test:e2e

Environment Variables for Development:

For end users preferring prebuilt binaries, the project distributes signed installers at downloads.coworker.ai for all supported platforms—no compilation required.

Real Code Examples

The repository's development documentation provides concrete command references. Below are the actual examples present, with context for their use:

Basic Development Workflow:

pnpm install
pnpm dev

This two-command setup reflects the project's intentional simplicity. pnpm install resolves workspace dependencies across the monorepo structure (apps/desktop/, packages/shared/), while pnpm dev starts the Electron main process, preload script, and React renderer with hot reloading via Vite.

Clean Development Reset:

pnpm dev:clean

Useful when debugging state-related issues. The clean variant ensures no stale configuration, cached credentials, or partial task histories interfere with reproduction.

Production Build Verification:

pnpm build
pnpm -F @coworker/desktop test:e2e

The build command compiles TypeScript across workspaces, bundles the React application, and prepares Electron packaging. Following with E2E tests validates the packaged artifact using Playwright—critical given the application's OS-level interactions (file system, keychain, browser automation).

Note: The README does not contain extensive inline code examples for the user-facing automation syntax (skill definitions, prompt templates, or configuration files). The project's current documentation focuses on development setup rather than end-user scripting APIs. This reflects the project's stage—functional but still building out user-facing documentation. Developers should expect to inspect the source or community resources for advanced scripting patterns.

Advanced Usage & Best Practices

Credential Management API keys are stored in the OS keychain, not plaintext configuration. When switching between providers (e.g., testing Claude vs. local Llama), use the application's settings UI rather than environment variables—this maintains the security model and prevents accidental commits of credentials.

Scope Folder Access Conservatively The permission model requires explicit folder grants. Start with a single project directory or ~/Downloads rather than full home directory access. This limits blast radius during experimentation and aligns with the principle of least privilege.

Local Model Performance Considerations Running via Ollama eliminates API costs but demands sufficient local compute. For file-content analysis or multi-step browser automation, smaller models (7B-13B parameters) may struggle with complex reasoning. The supported provider list lets you route heavy tasks to cloud APIs and lightweight tasks to local models—mix strategically based on latency and cost constraints.

Skill Versioning Custom skills represent structured automation. Treat them as code: version in git, document expected inputs/outputs, and test with E2E_SKIP_AUTH=1 in a clean environment before relying on them for production workflows.

Architecture Familiarization The CLAUDE.md file in the repository contains detailed architecture documentation. For developers extending Coworker—adding new tool integrations, modifying the daemon behavior, or building alternative UIs—this is essential reading before diving into source files.

Comparison with Alternatives

Trade-offs to consider: Power Automate offers deeper enterprise connectors (SharePoint, Dynamics) but locks you into Microsoft's cloud and pricing. AutoGPT explores more open-ended agent behavior but lacks the polished desktop integration and scoped permissions model. Raycast AI provides superior UX for quick AI-assisted lookups but doesn't automate file operations or browser workflows systematically.

Coworker's position is strongest for developers prioritizing data locality, model flexibility, and hackability—willing to trade some polish for control.

FAQ

Is accomplish-ai/openwork free to use? Yes. The project is MIT licensed with no subscription fees. You pay only for API usage if using cloud providers, or nothing if using local models via Ollama.

Does it run entirely offline? Yes, when configured with Ollama or LM Studio. Cloud providers require internet connectivity for API calls, but no data routes through Coworker's servers.

Which operating systems are supported? macOS (Apple Silicon and Intel), Windows 11, and Ubuntu (ARM64 and x64). The Linux builds are distributed as AppImage and .deb packages.

How does the approval workflow function? Every action requires explicit user confirmation. Logs are visible, and execution can be stopped at any time. This prevents runaway automation from modifying unintended files.

Can I contribute to development? Yes. The repository accepts pull requests. Standard fork-branch-PR workflow applies, with pnpm-based build and test commands.

What Node.js version is required? Node.js 20+ and pnpm 9+ are specified prerequisites.

Is there detailed architecture documentation? Yes, see CLAUDE.md in the repository root for in-depth technical documentation of the Electron app, daemon process, and OpenCode integration.

Conclusion

accomplish-ai/openwork fills a specific niche in the current AI tooling landscape: a local, actionable, user-controlled agent that doesn't require surrendering data to cloud services or committing to recurring subscriptions. Its 10,901 GitHub stars and active development indicate genuine developer interest, while the MIT license and minimal setup requirements lower barriers to both use and contribution.

The project is best suited for privacy-conscious developers, teams in regulated industries, local-LLM enthusiasts, and automation builders who want more control than SaaS tools provide but more structure than scripting from scratch. It's less appropriate for users wanting turnkey enterprise integrations or fully autonomous agents without oversight.

The current documentation leans development-heavy over end-user scripting examples—reflecting a project still maturing its user-facing surface. For developers comfortable reading TypeScript and exploring architecture docs, this presents opportunity; for pure end-users, expect a learning curve.

Explore the repository, download a prebuilt release for your platform, or contribute to the open-source effort at https://github.com/accomplish-ai/openwork.

For related coverage on local LLM deployment strategies, see [INTERNAL_LINK: running-ollama-production].