iPolloWork
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.
Evidence shows permission approval, local control, data flow description (e.g., architecture boundary), but lacks implementation details. Deductions: no specific least-privilege mechanisms, user confirmation flows, detailed data flow transparency, sensitive data handling measures, dependency security audit results, explicit external effect controls, rollback mechanisms, or source attribution verification.
Self-consistency is good, README aligns with code structure, but dependency availability is unverified and failure messages lack concrete examples. Deductions: dependency availability only asserted, failure messages not demonstrated.
Clear target audience and scenarios, capability boundaries well-defined (local-first, extensible), but trigger precision not detailed, environment fit documented but unverified. Deductions: trigger precision lacks specifics, environment fit unverified.
Information architecture clear, install notes detailed, but naming stability unverified, examples and FAQ insufficient, known limitations not explicit, license clear but not open-source, versioning/changelog absent, maintenance responsibility unclear. Deductions: naming stability, examples/FAQ, known limitations, versioning/changelog, maintenance responsibility all insufficient.
Output usability described (editable results), marginal value clear (alternative to Codex/Claude Code), but cost-benefit not quantified. Deductions: cost-benefit lacks data.
Claim traceability moderate, cross-source corroboration insufficient, fact-inference separation unclear. Deductions: lack of concrete evidence for claims, no distinction between facts and inferences.
- License is source-available, not OSI-approved, with many restrictions; evaluate compliance carefully.
- Publisher identity unverified; treat with caution.
- Dependency security not audited; potential risks.
- Specific implementations of data flow and permission controls not shown; further review needed.
What does this agent do, and when should you use it?
iPolloWork (repository Devin-AXIS/iPolloWork) is a desktop AI workspace that unifies repositories, local files, browser tasks, documents, presentations, websites, design, and video in one place for agents. You describe the outcome; the agent plans and executes; you inspect the work, approve actions, and keep editing the result in the same interface. Architecturally, an Electron desktop shell talks to a local API served by the iPolloWork server, which drives OpenCode for agent execution; OpenCode is downloaded as a separate sidecar and remains independently upgradable. The optional iPolloCloud connection covers accounts, organization administration, hosted workers, payments, and mobile apps, none of which are required for local use. Licensing is the iPolloWork Source Available License 1.0, not an OSI-approved open-source license: free for individual personal use and internal use by fewer than three total users; any use by three or more users or any commercial/customer-facing use requires prior written authorization.
Once installed as a desktop app or run from source, iPolloWork provides agent-first execution: the agent plans work, uses tools, reads and modifies local files, runs commands, and continues from the current state. Outputs go beyond code—editable documents, web pages, presentations, visual designs, and videos stay modifiable in the same workspace after generation. The execution path is: iPolloWork desktop/UI → local API → iPolloWork server → OpenCode, with optional account/control requests routed to iPolloCloud. The workspace is extensible via Skills, plugins, MCP servers, and browser automation. Optionally, ./ipollowork dev:cloud <URL> connects the client to an iPolloCloud control plane for authentication.
- An individual developer who wants a Codex-like coding agent without results being trapped in a chat transcript, so code and files remain directly editable.
- A small team producing decks, landing pages, or promo videos who needs outputs that stay editable rather than finished one-off files.
- Privacy- and permission-conscious users who want the workflow to run locally with their own model or provider and approve agent actions step by step.
- Advanced users extending agent capabilities through MCP servers, plugins, or browser automation.
- Teams wanting to self-host or point at their own cloud control plane via dev:cloud with a local or custom-domain URL.
What are this agent's strengths and limitations?
- Editable results: documents, web pages, presentations, designs, and videos remain modifiable in the same workspace after generation, instead of a chat transcript or a finished file.
- Local control: runs on your machine, bring your own model or provider, approve permissions individually; local use does not require an iPolloCloud account.
- Clean, extensible architecture: OpenCode is a separate, independently upgradable sidecar that is not forked; the workspace extends via Skills, plugins, MCP servers, and browser automation.
- Complete cross-platform coverage: official releases include macOS (ARM64/x64), Windows (x64/ARM64), and Linux (x64/ARM64) installers.
- Restrictive license: iPolloWork Source Available License 1.0 requires prior written authorization for any use by three or more users and for any sale, SaaS, hosting, white-label, or customer-facing use; branding must remain visible.
- High build-from-source barrier: Node.js 22+, pnpm 11, Bun 1.3.10+, and native toolchains (Xcode CLT, VS 2022 Build Tools, or a full Linux Electron build environment) are required.
- Locally packaged artifacts are unsigned unless you supply Apple/Windows signing credentials; unsigned Windows installers may trigger SmartScreen, and the full signed/notarized matrix requires the GitHub release workflow.
- Despite the Codex-like positioning, full product scope (accounts, hosted workers, payments, mobile apps) lives in the separate iPolloCloud; this repository ships only the client and local runtime.
How do you install or deploy this agent?
Option 1 (recommended): download the installer matching your OS and CPU from GitHub Releases—macOS Apple Silicon: ipollowork-mac-arm64-<version>.dmg, Intel: -x64; Windows: ipollowork-win-x64-<version>.exe (ARM64: -arm64); Linux: ipollowork-linux-*.AppImage (chmod +x and run). On macOS, open the .dmg and drag iPolloWork into Applications; on Windows, run the .exe (a locally built unsigned installer may trigger SmartScreen).
Option 2 (from source): requires Git, Node.js 22+, pnpm 11 (corepack enable), Bun 1.3.10+, plus native toolchains (macOS: Xcode CLT; Windows: VS 2022 Build Tools with C++ and the Windows SDK; Linux: an Electron build environment).
macOS/Linux:
git clone https://github.com/Devin-AXIS/iPolloWork.git
cd iPolloWork
corepack enable
./ipollowork setup
./ipollowork devWindows PowerShell:
git clone https://github.com/Devin-AXIS/iPolloWork.git
Set-Location iPolloWork
corepack enable
.\ipollowork.cmd setup
.\ipollowork.cmd devThe first build downloads the OpenCode sidecar and builds the local Orchestrator.
How do you use this agent?
Start the Electron desktop client with ./ipollowork dev, or only the browser UI with ./ipollowork dev:ui. Development mode uses isolated iPolloWork/OpenCode state and does not overwrite your normal OpenCode configuration. To connect a cloud control plane, start your local iPolloCloud first, then run ./ipollowork dev:cloud http://localhost:3100 (or a self-hosted URL like https://cloud.example.com); this creates an isolated dev profile and requires Cloud sign-in. Run ./ipollowork check for type checks and tests, ./ipollowork build for a production build, and ./ipollowork package:dir or ./ipollowork package for local packaging (outputs in apps/desktop/dist-electron/; --dry-run previews the next version). In the app, describe a goal, inspect the agent's work, approve its actions, and keep editing the results.
How does this agent compare with similar options?
The README positions iPolloWork as an open alternative to Codex and Claude Code: its differentiators are the local-first visual workspace and editable multi-format outputs (documents, websites, presentations, design, video) beyond pure coding. It uses OpenCode as its execution sidecar without forking or rewriting it.