iPolloWork

One-Line Pitch

iPolloWork is a local-first visual AI workspace that directly produces editable code, documents, presentations, websites, designs, and videos from a single goal, while using DeepSeek Harness as an optional sub-agent for collaboration. It can be used as a standalone desktop application or loaded as an extension repository for DSH profiles.

Core Capabilities

• Centralize a workspace to handle code repositories, local files, browser tasks, documents, presentations, websites, designs, and videos—no need to switch contexts between different tools
• Enable AI agents to plan tasks, invoke tools, read/write files, run commands, and continue progress from the current state instead of just delivering a chat transcript
• Output remains editable: after generating documents, websites, presentations, designs, and videos, text, images, layouts, and frames can still be manually refined
• Extend AI capabilities through Skills, plugins, MCP, local services, and browser automation; plugin清单 is uniformly described via ipollowork.plugin.json
• Optionally connect to iPolloCloud for account, organization, hosted worker lifecycle, and commercial Apps; pure local mode requires no account
• Inject DeepSeek Harness as a sidecar runtime, allowing code review, development, and research tasks to be delegated as DSH sub-tasks with progress viewing

Technical Implementation

• Language: TypeScript + JavaScript (hybrid)
• Key Dependencies: Electron 35 (desktop host), @opencode-ai/sdk 1.18.16 (model & tool bridge), better-sqlite3 11 (local storage), @lydell/node-pty (local terminal), drizzle-orm (ORM)
• Architecture Pattern: pnpm monorepo, main body consists of apps/app (React UI), apps/desktop (Electron shell), apps/server (file API), apps/orchestrator (headless orchestration), apps/installer (packaging); the desktop shell loads OpenCode, Orchestrator, and DSH all as sidecars; plugin resources are described via examples/plugin-packages/*/ipollowork.plugin.json; DSH sub-agents are injected into the DSH Cordis container via cordis.patch.yml and dsh.bundle.patch
• Entry Files: apps/desktop/electron/main.mjs (Electron main process), apps/server/src/cli.ts (server CLI), apps/orchestrator/bin/ (headless orchestrator)

Use Cases

Suitable for non-technical users, designers, content creators, and developers: describe "make a poster / write a report / get a certain repository feature working" in one application, then continue letting AI or yourself edit in the same place instead of just getting a screenshot as the end result. People already using DSH who want to integrate visual design, document, PPT, and video capabilities into their workflow will also benefit, because this repository carries both DSH sub-agent collaboration examples (examples/plugin-packages/deepseek-harness) and production-ready DSH plugins (external-plugins/deepseek-harness/design-studio, etc.).

Prerequisites & Compatibility

Installation

dsh plugin --profile web add github:Devin-AXIS/iPolloWork

Configuration Options

FAQ

Q: Can I double-click to open it after installation?

A: Yes, but you need to install the desktop application to your system using one of the three official installation methods from the README (macOS .dmg, Windows .exe installer, Linux .AppImage). Loading the DSH profile this time only adds the repository code to the plugin list—it won't install the system-level desktop app for you.

Q: How does iPolloWork work with DSH?

A: It packages DSH 0.1.0-rc.6 as a local sidecar via apps/desktop/dsh-runtime, then declares a set of contracts in examples/plugin-packages/deepseek-harness/ipollowork.plugin.json: capabilities, runtime_status, runtime_install, runtime_update, runtime_remove, start, status, cancel—allowing iPolloWork to delegate clearly scoped tasks to DSH sub-agents.

Q: Do I need to pay or log in to use it?

A: Not required. The desktop app's local mode doesn't need any account; iPolloCloud is an optional connection that only participates when you actively connect to remote worker organizations or commercial Apps.

Q: Will it fork OpenCode?

A: No. OpenCode remains as an independently downloaded and upgraded component; iPolloWork does not rewrite or fork its code—the sidecar boundary is clear.

Q: Where is data stored?

A: Working files go into three subdirectories under the current workspace: design/, design/<sessionId>-ippt/, and video/; sessions, settings, and tokens are in local DSH home; iPolloCloud only participates after explicit login.

Q: Does it use an open source license?

A: No, it uses iPolloWork Source Available License 1.0: free for personal use and small-scale internal use by fewer than three people; any use by three or more people, commercial use, SaaS, or white-label distribution requires written authorization; third-party components continue to follow their respective licenses.

Q: Can I get full functionality on Linux?

A: The desktop app body runs on Linux, but building once requires a full C/C++ toolchain; Windows code signing/SmartScreen prompts and macOS signing/notarization experiences need verification on their respective platforms.

Learning Curve

Advanced — using it only requires double-clicking the installer, but running ./ipollowork CLI or building manually requires having Node 22+, pnpm 11, bun 1.3.10+, and system-level C/C++ toolchain all set up, plus understanding the monorepo's dev/build/package three-layer commands.

Known Issues & Limitations

• The current latest stable version does not yet include DeepSeek Harness sub-agent collaboration capability; the DSH integration source code is already available in the repository, but README.md:39-45 explicitly states it is still under active development
• Running ./ipollowork.cmd dev on Windows does not automatically register the ipollowork:// protocol handler; when testing Cloud login via an external browser, you need to manually switch, then restore production protocol handling
• Currently only packages builds for the current OS and CPU architecture; cross-platform matrix requires going through the GitHub Releases process; without Apple/Windows signing credentials, locally produced builds are unsigned and not suitable for official release
• Local release sequence starts from 0.0.0, official versions follow 0.1.0–0.99.0 then 1.0.0; local packaging doesn't automatically push or git tag; new versions require manually triggering the process
• There are 4 TODOs in the source code: apps/app/src/react-app/domains/settings/pages/recovery-view.tsx mentions "restore disabled condition state" three times, apps/app/src/components/chat/message-list.tsx mentions "add tone for file messages"
• The license is iPolloWork Source Available License 1.0, not an OSI open source license; use by more than three people, commercial use, SaaS, and white-label all require written authorization
• The dsh.bundle.patch scope for DSH sub-plugins like external-plugins/deepseek-harness/design-studio is >=0.0.1-rc.1 <0.2.0-0; DSH 0.2.0+ requires waiting for plugin releases to catch up

English · 简体中文 · 繁體中文 · 日本語

A local-first visual AI workbench that turns one goal into editable code, documents, presentations, websites, designs, and videos—an open alternative to Codex and Claude Code.

https://github.com/user-attachments/assets/201b561a-22ec-4c8e-a4e8-f34172cf0aa3

iPolloWork gives agents one workspace for repositories, local files, browser tasks, documents, presentations, websites, design, and video. Describe the outcome; the agent plans and executes; you inspect the work, approve actions, and keep editing the result in the same place.

Codex-style coding is only the starting point. When the output is a deck, web page, visual design, or video, iPolloWork keeps it editable instead of handing you a finished file or a chat transcript.

What makes it different

• Agent-first execution — plan work, use tools, read and modify files, run commands, and continue from the current state.
• Editable results — move from code to documents, websites, presentations, design, and video; keep changing text, images, layout, and scenes after generation.
• Local control — run on your machine, bring your own model or provider, approve permissions, and extend the workspace with Skills, plugins, MCP servers, and browser automation.
• Two agent ecosystems, one workflow — native DeepSeek Harness subagent collaboration is in active development, designed to let iPolloWork delegate focused work to DSH while both sides keep their own Skills and plugins.

DeepSeek Harness subagent collaboration

iPolloWork is integrating DeepSeek Harness (DSH) as an optional subagent runtime. The integration is in active development and is not included in the latest stable release yet.

The collaboration model keeps iPolloWork as the primary workspace: a task can delegate bounded work to DSH subagents when useful, then bring structured results back into the same task. iPolloWork and DSH retain their own Skills and plugin ecosystems, so users can benefit from both without replacing either runtime.

Install iPolloWork

Download the desktop app

Official installers are published on GitHub Releases. If you prefer a manual download, choose the file that matches both your operating system and CPU:

The macOS .zip and Linux .tar.gz files are portable/update artifacts; most users should choose .dmg, .exe, or .AppImage. If the Releases page does not yet contain an installer for your system, run or package the app from source below.

Installation after downloading:

• macOS: open the .dmg, then drag iPolloWork into Applications.
• Windows: run the .exe installer. A locally built, unsigned installer may trigger Microsoft Defender SmartScreen.
• Linux: make the AppImage executable with chmod +x ipollowork-*.AppImage, then run it. The .tar.gz package can be extracted and run without installation.

Requirements for source development and packaging

• Git
• Node.js 22 or newer
• pnpm 11, enabled through Corepack with corepack enable
• Bun 1.3.10 or newer, used to build the local Orchestrator sidecar
• macOS: Xcode Command Line Tools (xcode-select --install)
• Windows: Visual Studio 2022 Build Tools with Desktop development with C++ and the Windows SDK; use PowerShell or Command Prompt
• Linux: a standard Electron build environment with a C/C++ toolchain, Python 3, pkg-config, and the desktop libraries required by Electron; the release build uses Ubuntu 22.04

OpenCode is downloaded and prepared as a separate sidecar during the first desktop build. iPolloWork does not fork or rewrite OpenCode, and OpenCode can continue to be upgraded independently.

Start from source

macOS and Linux

git clone https://github.com/Devin-AXIS/iPolloWork.git
cd iPolloWork
corepack enable
./ipollowork setup
./ipollowork dev

Windows PowerShell

git clone https://github.com/Devin-AXIS/iPolloWork.git
Set-Location iPolloWork
corepack enable
.\ipollowork.cmd setup
.\ipollowork.cmd dev

The setup command installs the locked workspace dependencies. The dev command prepares the OpenCode and Orchestrator sidecars, starts the UI, and opens the Electron desktop client. Development mode uses isolated iPolloWork/OpenCode state and does not overwrite the user's normal OpenCode configuration.

Development commands

Windows development builds do not register the production ipollowork:// handler automatically. When testing Cloud sign-in through an external browser, use the repository's protocol switcher and restore the production handler when you finish. See Windows protocol switching.

Build and package

There are three different build levels:

macOS and Linux

./ipollowork check
./ipollowork package:dir
./ipollowork package

Windows PowerShell

.\ipollowork.cmd check
.\ipollowork.cmd package:dir
.\ipollowork.cmd package

All outputs are written to apps/desktop/dist-electron/:

package is the local release command. It keeps the App, Desktop, Orchestrator, and Server versions in sync, and uses the sequence 0.1.0 through 0.99.0, then 1.0.0 (the source checkout starts at the unshipped baseline 0.0.0). Use ./ipollowork package --dry-run to inspect the next version, or --skip-check only when the checks have already passed. Local packaging never commits, tags, pushes, or publishes a release.

• macOS: .dmg, .zip, and an unpacked .app
• Windows: NSIS .exe and win-unpacked/
• Linux: .AppImage, .tar.gz, and linux-unpacked/

Local packaging targets the machine's current operating system and CPU architecture. Use the GitHub release workflow to produce the complete signed/notarized matrix for macOS ARM64/x64, Windows ARM64/x64, and Linux ARM64/x64. Local packages are unsigned unless the appropriate Apple or Windows signing credentials are supplied; they are suitable for development testing but should not be presented as official releases.

Connect to iPolloCloud

Start your local iPolloCloud control plane first, then run:

./ipollowork dev:cloud http://localhost:3100

This command creates an isolated development profile, points authentication and Cloud APIs at the supplied URL, and requires Cloud sign-in. It does not change the normal local iPolloWork profile. A remote or self-hosted Cloud URL works the same way:

./ipollowork dev:cloud https://cloud.example.com

Architecture boundary

iPolloWork desktop/UI ── local API ──> iPolloWork server ──> OpenCode
          │
          └── optional account/control requests ──> iPolloCloud

• Agent execution and streaming stay on the Work/Worker path.
• iPolloCloud handles identity, organizations, entitlements, hosted worker lifecycle, administration, and commercial Apps.
• The Cloud connection is optional. Local iPolloWork works without an account or commercial service.
• OpenCode remains its own component and can continue to be upgraded independently.

Repository layout

• apps/app — shared React user interface
• apps/desktop — Electron desktop shell and packaging
• apps/server — iPolloWork server API
• apps/orchestrator — headless runtime orchestration
• packages — shared types, components, docs, and integrations
• docs — maintained engineering notes, platform guides, and generated reports
• evals — executable product flows and validation tooling
• examples — complete example plugin packages
• external-plugins — independently released plugins for external agent hosts
• packaging — release and installer metadata
• scripts — development, build, audit, and release automation
• specs — product and architecture specifications
• vendor — pinned third-party source that is built as part of iPolloWork

Contributing

Read AGENTS.md, CONTRIBUTING.md, and apps/app/src/react-app/ARCHITECTURE.md before making product changes. Run the narrow relevant test first, followed by:

./ipollowork check
git diff --check

See CONTRIBUTING.md, CODE_OF_CONDUCT.md, and SECURITY.md for contribution, community, and security policies.

License

iPolloWork uses the iPolloWork Source Available License 1.0:

• Free only for individual personal self-use and for small internal use by fewer than three total users.
• Prior written authorization is required for any use by three or more users, regardless of whether the use is personal, internal, commercial, non-commercial, individual, or organizational.
• Prior written authorization is required for any sale, resale, paid service, SaaS, hosting, white-label distribution, marketplace use, or customer-facing use, regardless of whether it is done by an individual or a company.
• The iPolloWork name, logo, and product attribution must remain visible in user-facing frontend displays unless prior written authorization expressly permits different branding.
• Separately licensed third-party components and code previously released under MIT retain their original licenses and existing rights.

See LICENSE for the controlling terms and LICENSES/MIT-legacy.txt for the historical MIT notice. This is a source-available license, not an OSI-approved open-source license.