# Waynode > Open-source durable worktrees for coding agents. Each worktree is a real cloned Git repository with a persistent branch, agent session, terminal, and review surface, reachable from desktop and mobile. Waynode gives coding work a real, durable place. Start a task at your desk, inspect the diff on your phone, and finish it from any device, with the repository, branch, terminal, and conversation still there. ## What Waynode is - A persistent repo workspace, not a coding chat. Every space is a real cloned GitHub or GitLab repository on disk. - An agent-native Git surface: changed files, hunks, commits, branches, and push live beside the conversation. "Done" means ready for review, not merely finished running. - Mobile-first: the same workspace, session, and diff on your phone. Follow a live task, review changed files, send the next instruction. - Open source (MIT) and self-hostable with Docker. The agent engine is [pi](https://github.com/anthropics/pi), with pi-codex-goal for autonomous goals. ## Two ways to run it ### Self-host: free and yours ```bash git clone https://github.com/fornace/waynode.git cd waynode ./scripts/self-host.sh setup ``` The guided installer requires Docker Compose v2, one GitHub or GitLab OAuth application, and a supported model-provider key. It generates the server secrets, validates the configuration, and starts Waynode on loopback by default. See the [self-hosting guide](https://github.com/fornace/waynode/blob/main/docs/SELF-HOSTING.md) for HTTPS, upgrades, backup, and restore. Your repositories, database, credentials, provider accounts, and billing stay with you. Bring your own LLM keys. ### Waynode Cloud: managed hosting The same open-source product, managed: server operation, updates, encrypted secrets, hardware-isolated agent runs, and Stripe billing. Every new organization gets a 15-day trial. Hosted worktrees include chat and goals plus Git review, commit, and push. Interactive terminal access is deliberately self-hosted only. Hosted plan, quota, and subscription details appear inside the organization billing settings rather than as public plan cards. ## For AI assistants - Every HTML page on this site has a markdown twin: append `.md` to the URL. - [/llms.txt](/llms.txt): index of all agent-readable content - [/llms-full.txt](/llms-full.txt): every article concatenated - [/learn.md](/learn.md): guides and comparisons index ## Links - Website: https://waynode.fornace.net - GitHub: https://github.com/fornace/waynode - Guides and comparisons: /learn --- --- title: Waynode vs Coder description: How Waynode's lightweight self-hosted agent workspace compares to Coder's enterprise cloud development environment platform in 2026. category: compare slug: waynode-vs-coder date: 2026-07-12 updated: 2026-07-12 author: Francesco Frapporti keywords: waynode vs coder, coder.com alternative, self-hosted dev environment coding agent cover: /covers/waynode-vs-coder.png --- ![Waynode vs Coder Cover Image](/covers/waynode-vs-coder.png) # Waynode vs Coder Coder is a self-hosted platform for provisioning cloud development environments at enterprise scale: workspaces are defined in Terraform and can run on Kubernetes, EC2, or Docker, with AI agents layered on top through Coder Agents. Waynode is a much smaller, MIT-licensed workspace built specifically around a coding agent: each workspace is a persistent cloned Git repository with the agent, diffs, branches, and a terminal in one place. If you operate developer infrastructure for hundreds of engineers, Coder is the right category; if you are a small team that wants a durable self-hosted place for an agent to work in your repos, Waynode is the lighter fit. **TL;DR** - **Coder**: AGPL-3.0 core plus enterprise license, workspaces defined in Terraform, runs on Kubernetes/EC2/Docker, ~13.8k GitHub stars as of July 2026. Built for platform teams managing fleets of dev environments; AI agents are a feature of that platform ([github.com/coder/coder](https://github.com/coder/coder)). - Coder's agent story is in transition: Coder Tasks is deprecated (removed from releases starting v2.37, September 1, 2026) in favor of Coder Agents, a control-plane-native agent currently in beta ([Coder Tasks docs](https://coder.com/docs/ai-coder/tasks)). - **Waynode**: MIT, guided Docker Compose self-hosting, agent-first design (pi engine, autonomous goal runs), persistent Git-native workspaces, mobile-first review-and-steer. No Terraform or Kubernetes required, but you still configure OAuth, a model provider, HTTPS, and backups. - Pick Coder for enterprise scale, governance (audit logs, RBAC, quotas: Premium tier), and IDE-centric cloud dev environments. Pick Waynode for small-team simplicity where the agent is the primary worker and you review from anywhere. ## What is Coder? Coder (coder.com) is a self-hosted cloud development environment (CDE) platform. Administrators define workspace templates in Terraform, and those templates can provision environments as Kubernetes pods, EC2 VMs, or Docker containers, connected through a secure WireGuard tunnel and automatically shut down when idle ([github.com/coder/coder](https://github.com/coder/coder)). Developers connect with VS Code, JetBrains, or the web UI. The core is dual-licensed: AGPL-3.0 for the Community edition, plus a commercial enterprise license. The free Community tier includes unlimited workspaces and templates, unlimited members within a single organization, and OIDC single sign-on; the Premium tier (priced annually per user, no public dollar figure) adds audit logging, RBAC, resource quotas, multi-organization access controls, high-availability replicas, and SLA-backed support ([coder.com/pricing](https://coder.com/pricing)). ## What is Coder's AI agent feature in 2026? Coder has two overlapping agent systems, and it matters which one you evaluate: - **Coder Tasks** is an interface for running terminal-based coding agents (Claude Code, Goose, any MCP-capable agent) inside Coder workspaces. It is deprecated: Tasks enters a 12-month Extended Support Release for Premium customers on June 2, 2026, and is removed from new releases beginning with v2.37 on September 1, 2026 ([Coder Tasks docs](https://coder.com/docs/ai-coder/tasks)). - **Coder Agents** is the long-term replacement, currently in beta. The agent loop runs in the Coder control plane rather than inside the workspace, so workspaces can be fully network-isolated and LLM provider credentials never enter them. It supports Anthropic, OpenAI, Google, Azure OpenAI, AWS Bedrock, and OpenAI-compatible endpoints, with sub-agent delegation and a chat UI ([Coder Agents docs](https://coder.com/docs/ai-coder/agents)). Both Community and Premium deployments include 1,000 agent workspace builds for proof-of-concept use; scaling beyond that requires the paid AI Governance add-on ([Coder Tasks docs](https://coder.com/docs/ai-coder/tasks)). This architecture suits enterprises well: centralized model configuration, isolated execution, and governance hooks. The trade-off is that the agent capability is attached to a platform you must first operate: Terraform templates, a control plane, and typically an orchestrated production deployment. ## What is Waynode? Waynode is an open-source (MIT), self-hosted coding-agent workspace ([github.com/fornace/waynode](https://github.com/fornace/waynode)). The design inverts Coder's: instead of a dev-environment platform that gained agents, Waynode starts from the agent loop and builds the workspace around it. - Each workspace ("space") is a **real cloned Git repository** on disk, a persistent worktree, not a disposable task container. - The agent engine is **pi**, with **pi-codex-goal** for autonomous goal-driven runs; you can chat, send a goal, or open a full terminal in the workspace. - Git is a first-class surface: changed files, hunks, diffs, commits, branches, and push live beside the conversation. "Done" means ready for review, not merely finished running. - Sessions persist: conversation, files, branches, and terminal state survive between visits, and the same workspace works from a phone: follow a live task, review diffs, steer, push. - Repo providers: GitHub and GitLab via OAuth. Self-hosting starts with `git clone` and `./scripts/self-host.sh setup`. The guided installer requires Docker Compose v2, a GitHub or GitLab OAuth app, and a supported model-provider key; it generates the server secrets, validates Compose, and starts Waynode on loopback. See [/guides/self-host-coding-agent-docker](/guides/self-host-coding-agent-docker) for the full walkthrough. There is no Terraform, template authoring, or Kubernetes requirement. The default Compose deployment is for a trusted individual or small team; the separate KVM/microsandbox deployment is an advanced operator path. See [/learn](/learn) for an overview. ## Waynode vs Coder: comparison table | | Waynode | Coder | |---|---|---| | Category | Self-hosted coding-agent workspace | Self-hosted cloud dev environment platform | | License | MIT | AGPL-3.0 + enterprise license ([repo](https://github.com/coder/coder)) | | Self-host install | Guided Docker Compose script; OAuth and model key required | Install script/binary for evaluation; Kubernetes or other hosted platforms for production multi-user installs ([install docs](https://coder.com/docs/install)) | | Workspace definition | Cloned Git repo, persistent worktree | Terraform templates (K8s pods, EC2 VMs, Docker) | | Agent | pi engine built in; chat, autonomous goals, terminal | Coder Agents (beta, control-plane loop); Tasks deprecated Sept 2026 ([docs](https://coder.com/docs/ai-coder/agents)) | | Model configuration | Self-host: bring your own keys. Cloud: hosted tiers (Fornace models, GLM, Qwen) | Admin-configured: Anthropic, OpenAI, Google, Azure OpenAI, Bedrock, OpenAI-compatible | | Git review surface | Diffs, hunks, commits, branches, push beside the conversation | Workspace-level; review via connected IDE | | Mobile | Mobile-first web; native macOS/iOS clients planned | Web dashboard; IDE-centric workflow | | Governance (SSO, audit, RBAC, quotas) | Not offered | OIDC SSO free; audit/RBAC/quotas in Premium ([pricing](https://coder.com/pricing)) | | Free-tier limits | Fully free self-host, MIT | Unlimited workspaces; 1,000 agent builds, then AI Governance add-on | | Managed option | Waynode Cloud: $39-$249/mo flat tiers | Premium: annual per-user, quote-based | ## When is Coder the better choice? Coder wins when: - You have a platform team and many developers. Terraform templates, quotas, autostop scheduling, and multi-cloud provisioning exist precisely to manage fleets of environments. Waynode has none of that machinery. - Governance is a requirement. Audit logging, RBAC, resource quotas, and multi-organization controls are Premium features Waynode does not claim to offer. - The IDE is central. Coder workspaces are built for VS Code and JetBrains connections; agents assist inside a human-first environment. - You need network-isolated agent execution at org scale. Coder Agents' control-plane loop keeps LLM credentials out of workspaces entirely, a strong design for regulated environments. ## When is Waynode the better choice? - You are a small team without platform engineers. One docker-compose stack versus a control plane and Terraform template authoring is a real operational difference. - The agent is the primary worker. Waynode's whole surface (goals, live diffs, branch/push beside the chat) is organized around delegating work and reviewing it, not around provisioning IDE backends. - You want durable, resumable agent sessions across devices. Start a goal at your desk, check the diff from your phone, push after review. Persistence of the worktree and conversation is the core primitive. - You want a stable agent surface today. Coder's agent layer is mid-transition (Tasks deprecated, Agents in beta); Waynode's agent loop is the product, not an add-on. - License simplicity matters. MIT versus AGPL-3.0-plus-enterprise is relevant if you embed or modify the stack. Waynode Cloud offers the same open-source stack managed: Starter $39/mo (3 seats, 3M agent tokens/mo, 10 GB), Pro $99/mo (10 seats, 8M tokens, 50 GB), Team $249/mo (25 seats, 20M tokens, 200 GB), with a 15-day free trial for new organizations. That is flat pricing rather than per-user annual quotes. For adjacent comparisons, see [/compare/waynode-vs-github-codespaces](/compare/waynode-vs-github-codespaces) and [/compare/waynode-vs-gitpod](/compare/waynode-vs-gitpod); for the broader hosting decision, see [/guides/self-hosted-vs-cloud-coding-agents](/guides/self-hosted-vs-cloud-coding-agents). ## FAQ ### Is Coder free to self-host? Yes. Coder's Community edition is AGPL-3.0 and free, with unlimited workspaces, templates, and members within a single organization. Governance features such as audit logging, RBAC, and resource quotas require the Premium tier, which is priced annually per user with no public list price ([coder.com/pricing](https://coder.com/pricing)). ### What happened to Coder Tasks? Coder Tasks is deprecated: it enters a 12-month Extended Support Release for Premium customers on June 2, 2026, and is removed from new Coder releases starting with v2.37 on September 1, 2026. Coder recommends migrating to Coder Agents, its control-plane-native replacement, which is currently in beta ([Coder docs](https://coder.com/docs/ai-coder/tasks)). ### Can Waynode replace Coder for a large engineering organization? Not in general. Waynode does not offer Terraform-based provisioning, resource quotas, audit logs, RBAC, or high-availability replicas, the features large organizations buy Coder Premium for. Waynode targets small teams that want an agent workspace, not a fleet-management platform. ### Do both tools keep code on my infrastructure? Yes, when self-hosted. Coder runs workspaces on your Kubernetes clusters, VMs, or Docker hosts; Waynode's self-host mode keeps repos, database, credentials, and LLM keys on your own machine, with model API calls going to whichever provider you configure. ### Which is easier to install? Waynode: clone the repo and run `./scripts/self-host.sh setup`; the installer walks through OAuth and model-provider credentials before starting Docker Compose. Coder installs via a shell script or binary for evaluation, while production multi-user deployments run on Kubernetes or other hosted platforms and require authoring Terraform workspace templates ([install docs](https://coder.com/docs/install)). --- --- title: Waynode vs Cursor background agents description: How Waynode's self-hosted agent workspaces compare with Cursor's cloud agents on hosting, persistence, mobile review, and pricing. category: compare slug: waynode-vs-cursor-background-agents date: 2026-07-12 updated: 2026-07-12 author: Francesco Frapporti keywords: waynode vs cursor, cursor background agents alternative, cursor cloud agent self-hosted cover: /covers/waynode-vs-cursor-background-agents.png --- ![Waynode vs Cursor background agents Cover Image](/covers/waynode-vs-cursor-background-agents.png) # Waynode vs Cursor background agents Cursor's background agents (now called Cloud Agents) run coding tasks in isolated VMs managed by Cursor and hand you back a branch or pull request; they are a feature of the Cursor IDE and its subscription. Waynode is an open-source (MIT), self-hosted workspace where the agent works inside a persistent clone of your repository, with the diff, branches, and terminal living beside the conversation on desktop and mobile. Choose Cursor if you live in its IDE and want managed fire-and-forget task execution; choose Waynode if you want the agent's workspace on your own infrastructure and a place you can return to from any device. **TL;DR** - Cursor Cloud Agents run in "isolated VMs in the cloud with full development environments" on Cursor's infrastructure by default; execution can be delegated to your machines, but orchestration and model inference stay on Cursor's servers ([Cursor docs](https://cursor.com/docs/cloud-agent), [self-hosted docs](https://cursor.com/docs/cloud-agent/self-hosted)). - Waynode is fully self-hostable: repos, database, credentials, and LLM keys stay with you (guided Docker Compose setup), or use Waynode Cloud managed hosting from $39/mo. - Cursor's agent workspaces are per-task; Waynode spaces are persistent Git worktrees where conversation, files, branches, and terminal state survive between visits. - Both offer mobile access. Cursor exposes agents via Cursor Web and an iOS app; Waynode is mobile-first around the same workspace, session, and diff, with an agent-native Git review surface. - Cursor plans: Hobby free, Individual $20/mo, Teams $40/user/mo, Enterprise custom; Cloud Agents billed at API pricing on top ([cursor.com/pricing](https://cursor.com/pricing)). ## What are Cursor background agents (Cloud Agents)? Cursor Cloud Agents, the current name for what launched as background agents, are asynchronous coding agents that run in isolated cloud VMs rather than on your laptop. An agent clones your repository from GitHub, GitLab, Azure DevOps, or Bitbucket Cloud, works on a separate branch, and pushes changes back to your repo, typically as a pull request ([Cursor Cloud Agent docs](https://cursor.com/docs/cloud-agent)). Agents can be started from the Cursor desktop IDE (selecting the "Cloud" option), from Cursor Web at cursor.com/agents, from the Cursor iOS app, from Slack, GitHub, Bitbucket, or Linear via `@cursor` mentions, or through an API. Execution environments are defined per repo through agent-led setup, saved snapshots, or a Dockerfile referenced from `.cursor/environment.json` ([Cursor docs](https://cursor.com/docs/cloud-agent)). Billing is separate from the editor subscription's included usage: "Cloud Agents are charged at API pricing for the selected model," with spend limits set on first use ([Cursor docs](https://cursor.com/docs/cloud-agent)). The underlying plans are Hobby (free, limited agent requests), Individual at $20/month, Teams at $40 per user/month, and Enterprise at custom pricing ([cursor.com/pricing](https://cursor.com/pricing)). ## What is Waynode? Waynode is an open-source (MIT) coding-agent workspace you host yourself. Each workspace, called a "space", is a real cloned Git repository on disk: a persistent worktree, not a disposable task container. The agent engine is pi (open source), with pi-codex-goal for autonomous goal-driven runs; you can chat with the agent, send it an autonomous goal, or open a full terminal in the workspace. The Git surface is agent-native: changed files, hunks, diffs, commits, branches, and push live beside the conversation, so "done" means ready for review rather than merely finished running. Sessions persist: conversation, files, branches, and terminal state survive between visits, so you can start at your desk and resume from a phone. Repo providers are GitHub and GitLab via OAuth. Source: [github.com/fornace/waynode](https://github.com/fornace/waynode). There are two ways to run it. Self-hosting is free: clone the repo and run `./scripts/self-host.sh setup`; the guided installer collects the required OAuth and model-provider credentials, generates the server secrets, validates Compose, and starts on loopback. Your repos, database, credentials, LLM keys, and billing stay with you. Waynode Cloud is managed hosting of the same open-source stack: Starter $39/mo (3 seats, 3M agent tokens/mo, 10 GB), Pro $99/mo (10 seats, 8M tokens, 50 GB), Team $249/mo (25 seats, 20M tokens, 200 GB), with a 15-day free trial for new organizations. ## Where does the code actually run? This is the sharpest difference between the two. With Cursor Cloud Agents, the default is Cursor-managed VMs. Cursor does offer self-hosted execution modes ("My Machines" for individuals and "Self-Hosted Pool" for Enterprise teams), but these delegate only tool execution (terminal commands, file edits, browser actions) to your infrastructure. Agent orchestration and model inference remain on Cursor's servers, and "file chunks the model reads during inference" are still sent to Cursor. As the docs put it, self-hosted pools "do not move the agent loop out of Cursor's cloud." Self-Hosted Pool additionally requires an Enterprise plan, with capacity limits of 10 workers per user and 50 per team ([Cursor self-hosted docs](https://cursor.com/docs/cloud-agent/self-hosted)). With self-hosted Waynode, the entire stack runs on your infrastructure: the web app, the workspaces, the Git credentials, and the database. You bring your own model keys, so inference goes to the configured provider under your own account. Hosted billing is disabled on self-host. The default Compose deployment assumes trusted users; KVM/microsandbox deployment is a separate advanced operator path. If you want someone else to run it, Waynode Cloud operates the server, updates, encrypted secrets, and Stripe billing. Interactive terminal access is currently self-hosted only. In short: Cursor's "self-hosted" is hybrid: your machines execute, Cursor's cloud orchestrates and does inference. Waynode's self-hosted is the whole product. ## Comparison table | | Cursor Cloud Agents | Waynode | |---|---|---| | What it is | Agent feature of the Cursor IDE/platform | Standalone coding-agent workspace | | License | Proprietary | MIT, open source | | Where code runs | Cursor-managed VMs by default; hybrid self-hosted execution (orchestration and inference stay on Cursor's servers) ([docs](https://cursor.com/docs/cloud-agent/self-hosted)) | Fully on your infrastructure (self-host) or Waynode Cloud | | Workspace model | Per-task VM from a per-repo environment snapshot/Dockerfile ([docs](https://cursor.com/docs/cloud-agent)) | Persistent Git worktree per space; sessions survive between visits | | Repo providers | GitHub, GitLab, Azure DevOps, Bitbucket Cloud ([docs](https://cursor.com/docs/cloud-agent)) | GitHub, GitLab (OAuth) | | Review surface | Branch or pull request pushed to your repo | Diffs, hunks, commits, branches, push beside the conversation | | Terminal access | No interactive workspace terminal documented ([docs](https://cursor.com/docs/cloud-agent)) | Full terminal in the workspace | | Mobile | Cursor Web and iOS app to start and monitor agents ([docs](https://cursor.com/docs/cloud-agent)) | Mobile-first: same workspace, session, and diff; steer and push from a phone | | Models | Frontier model catalog, agents billed at API pricing ([pricing](https://cursor.com/pricing)) | Bring your own keys (self-host); fast/reasoning/max tiers on Cloud (Fornace models, GLM, Qwen) | | Pricing | Hobby free; Individual $20/mo; Teams $40/user/mo; Enterprise custom; agents billed at API pricing on top ([pricing](https://cursor.com/pricing)) | Self-host free; Cloud $39/$99/$249 per month with token allowances | ## Where Cursor is the better choice Cursor is first an IDE, and its agents benefit from that. If your team already writes code in Cursor, Cloud Agents are one click away in the editor and can be triggered from Slack, Linear, GitHub, and Bitbucket ([docs](https://cursor.com/docs/cloud-agent)). The managed VMs come with full development environments, infrastructure you never have to operate. Support for Azure DevOps and Bitbucket Cloud is broader than Waynode's GitHub/GitLab. For fire-and-forget tasks with a clear definition of done ("add tests, run them, open a PR"), a managed per-task VM is exactly the right shape, and you review the result as an ordinary pull request. ## Where Waynode is the better choice Waynode fits when the constraint is ownership or the workflow is longer than one task. If code cannot leave your infrastructure, self-hosted Waynode keeps everything, including which model provider sees your code, under your control, which Cursor's hybrid modes do not. If a piece of work spans days, a persistent worktree beats a fresh VM per task: the branch, the conversation, and the terminal state are still there when you come back. And if you review on the move, Waynode's mobile surface is built around the diff itself: follow a live task, read changed files hunk by hunk, steer the agent, and push a reviewed change from a phone. See [/learn](/learn) for the underlying model. The honest caveat in the other direction: Waynode is not an IDE. If you want tab completion and in-editor agents while you type, Cursor does that and Waynode does not try to. Some teams run both: Cursor as the editor, Waynode as the durable place where longer agent work lives. ## FAQ ### Can Cursor background agents run fully self-hosted? No. Cursor's My Machines and Self-Hosted Pool modes run tool execution on your machines, but agent orchestration and model inference remain on Cursor's servers, and file chunks read by the model are sent to Cursor ([Cursor docs](https://cursor.com/docs/cloud-agent/self-hosted)). Fully self-hosted operation, including model keys, requires a tool like Waynode. ### How much do Cursor Cloud Agents cost? Cloud Agents are billed at API pricing for the selected model, on top of a Cursor plan: Hobby is free with limited agent requests, Individual is $20/month, Teams is $40 per user/month, and Enterprise is custom ([cursor.com/pricing](https://cursor.com/pricing)). Waynode is free to self-host; Waynode Cloud starts at $39/month with 3M agent tokens included. ### Is Waynode a replacement for the Cursor IDE? No. Waynode is a workspace for agent-driven work (chat, autonomous goals, terminal, and Git review in one place), not an editor with completions. Teams can use Cursor for in-editor coding and Waynode for persistent, self-hosted agent sessions. ### Do Cursor agents keep a persistent workspace between tasks? Cursor agents start from a per-repo environment (snapshot or Dockerfile) and work per task, pushing results to a branch ([Cursor docs](https://cursor.com/docs/cloud-agent)). Waynode spaces are persistent worktrees: the conversation, files, branches, and terminal state survive between visits and across devices. ### Which is better for reviewing agent work on a phone? Both have mobile access. Cursor Web and the Cursor iOS app let you start and monitor agents, with review typically landing in a pull request ([Cursor docs](https://cursor.com/docs/cloud-agent)). Waynode is mobile-first around the workspace itself: the same session and diff appear on the phone, and you can steer the agent and push a reviewed change directly. --- --- title: Waynode vs Devin description: How Waynode's open-source, self-hosted agent workspace compares to Devin, Cognition's hosted autonomous AI software engineer, in 2026. category: compare slug: waynode-vs-devin date: 2026-07-12 updated: 2026-07-12 author: Francesco Frapporti keywords: waynode vs devin, devin alternative, open source devin alternative, self-hosted ai software engineer cover: /covers/waynode-vs-devin.png --- ![Waynode vs Devin Cover Image](/covers/waynode-vs-devin.png) # Waynode vs Devin Devin is a hosted autonomous AI software engineer from Cognition: you hand it a task, it works in a VM on Cognition's infrastructure, and you review the result. Waynode is an open-source (MIT) workspace you host yourself, where a coding agent works inside a real clone of your Git repository under your control. The choice is between autonomy-as-a-service on someone else's infrastructure and an owned, persistent workspace on yours. **TL;DR** - **Devin** is a managed product: web app, Slack/Teams integration, a CLI, its own cloud VMs, and usage-based pricing (Free, Pro $20/mo, Max $200/mo, Teams from $80/mo, Enterprise custom as of April 2026). - **Waynode** is MIT-licensed software with a guided Docker Compose installer: your repos, your database, your LLM keys. A managed Waynode Cloud tier exists (Starter $39/mo, Pro $99/mo, Team $249/mo) for teams that want the same stack hosted. - Devin's workspace is a task-scoped session on Cognition's infrastructure; Waynode's workspace is a persistent Git worktree on disk that survives between visits and devices. - Devin cannot be self-hosted; Waynode's self-hosted deployment is the primary, free way to run it. - Pick Devin for hands-off delegation with zero operations. Pick Waynode for code custody, model choice, and a durable place to work with an agent, including from a phone. ## What is Devin? Devin, built by Cognition, describes itself as "the AI software engineer, built to help ambitious engineering teams crush their backlogs" ([Devin docs](https://docs.devin.ai/get-started/devin-intro)). You interact through the web app at app.devin.ai, through Slack or Microsoft Teams by tagging Devin on a thread, or through the Devin CLI. Each session runs in Cognition's cloud with a shell, an editable IDE view, and a browser the agent uses for research and testing. Cognition's own guidance scopes Devin to tasks completable in roughly three hours. The platform has grown beyond single sessions: multi-agent orchestration ("Devin manages Devins"), automated code review (Devin Review for GitHub and GitLab), declarative environment blueprints, and 48+ MCP connectors, per the [release notes](https://docs.devin.ai/release-notes/overview). In April 2026 Cognition retired the earlier Core ($20 pay-as-you-go) and Team ($500/mo) plans and moved self-serve billing from ACUs to dollar-denominated quotas ([Cognition announcement](https://cognition.com/blog/new-self-serve-plans-for-devin)). The current lineup on the [pricing page](https://devin.ai/pricing/): Free, Pro at $20/mo, Max at $200/mo, Teams at $80/mo plus $40/mo per developer seat, and custom Enterprise (which retains ACU-based billing, plus SSO and a dedicated deployment option). Quotas refresh automatically; overages are billed at API pricing. ## What is Waynode? Waynode is an open-source (MIT), self-hosted coding-agent workspace ([GitHub](https://github.com/fornace/waynode)). Each workspace (a "space") is a real cloned Git repository on disk: a persistent worktree, not a disposable task container. The agent engine is pi (open source), with pi-codex-goal for autonomous goal-driven runs. You can chat with the agent, hand it an autonomous goal, or open a full terminal in the workspace. Git is the primary surface: changed files, hunks, diffs, commits, branches, and push sit beside the conversation, so "done" means ready for review rather than merely finished running. Sessions persist: conversation, files, branches, and terminal state survive between visits, and the same workspace, session, and diff work on a phone. GitHub and GitLab connect via OAuth. Two ways to run it: - **Self-host** (free, MIT): clone the repo and run `./scripts/self-host.sh setup`. The guided installer requires Docker Compose v2, an OAuth app, and a supported model-provider key; it generates secrets, validates Compose, and starts on loopback. Repos, database, credentials, LLM keys, and billing stay with you; hosted billing is disabled on self-host. - **Waynode Cloud** (managed hosting of the same open-source stack): Starter $39/mo (3 seats, 3M agent tokens/mo, 10 GB), Pro $99/mo (10 seats, 8M tokens, 50 GB), Team $249/mo (25 seats, 20M tokens, 200 GB), with a 15-day free trial for new organizations. Hosted models include fast/reasoning/max tiers (Fornace models, GLM, Qwen). ## Waynode vs Devin: side-by-side | | Waynode | Devin | |---|---|---| | Model | Open-source software you run (plus optional managed cloud) | Hosted product only | | License | MIT | Proprietary | | Self-hosting | Yes, the primary deployment path, free | No self-serve option; Enterprise lists a "dedicated deployment option" ([pricing](https://devin.ai/pricing/)) | | Where the agent works | A persistent Git worktree on your infrastructure | A session VM on Cognition's infrastructure | | Workspace lifetime | Persists between visits and devices | Task/session-scoped | | Interaction | Chat, autonomous goals, full terminal, Git panel; mobile web | Web app, Slack/Teams, CLI; shell/IDE/browser inside the session ([docs](https://docs.devin.ai/get-started/devin-intro)) | | Models | Bring your own keys (self-host); Fornace/GLM/Qwen tiers (cloud) | Cognition-managed models | | Repo providers | GitHub, GitLab (OAuth) | GitHub, GitLab (incl. Devin Review) ([release notes](https://docs.devin.ai/release-notes/overview)) | | Pricing | Free self-host; Cloud $39-$249/mo flat tiers | Free; Pro $20/mo; Max $200/mo; Teams $80/mo + $40/seat; Enterprise custom ([pricing](https://devin.ai/pricing/), [announcement](https://cognition.com/blog/new-self-serve-plans-for-devin)) | | Usage metering | Token allowances on Cloud; unmetered on self-host (your API costs) | Auto-refreshing quotas, dollar-billed overages; ACUs on Enterprise | | Multi-agent orchestration | No | Yes ("Devin manages Devins") | | Automated PR review product | No | Yes (Devin Review) | ## How does pricing actually compare? The models are hard to compare line-by-line because they meter different things. Devin's self-serve plans bundle a usage quota that refreshes automatically; when you exceed it, overages are billed at API pricing that varies by model and task complexity ([devin.ai/pricing](https://devin.ai/pricing/)). Heavy autonomous use is therefore variable-cost by design: the April 2026 restructure lowered the team entry point from $500/mo to $80/mo but kept consumption billing underneath ([Cognition](https://cognition.com/blog/new-self-serve-plans-for-devin)). Self-hosted Waynode has no software cost at all: you pay your own LLM API bills and server costs directly, with no markup and no intermediary metering. Waynode Cloud uses flat monthly tiers with included token allowances ($39/$99/$249). If your organization's constraint is predictable spend or the ability to route work to cheap or local models, self-hosting is the structural answer rather than a plan choice. ## Who owns the workspace and the code path? This is the core architectural difference, more than any feature. With Devin, your code is cloned into Cognition's session VMs, the models are Cognition's, and the workspace exists for the duration of the task. That is precisely what makes it zero-operations: environment blueprints, VM provisioning, and model routing are all someone else's job. The trade-off is that the entire loop (code, credentials, execution) runs on infrastructure you don't operate, and the public docs don't detail self-hosting; a dedicated deployment is an Enterprise conversation. With Waynode, the workspace is a directory on a machine you control. The session secret and encryption key are operator-owned, and OAuth apps are configured per deployment. The default Compose deployment assumes trusted users rather than hardware-isolating them; KVM/microsandbox deployment is a separate advanced operator path. The agent's work is ordinary Git state you can inspect with any tool. The trade-off runs the other way: you operate it (Docker, updates, keys), and you don't get Devin's managed extras like orchestrated fleets of agents or a turnkey PR-review product. ## When should you pick Devin? Pick Devin if you want delegation with no infrastructure: tag an agent from Slack on a bug, have it open a PR, and review the result. Its multi-session orchestration, Devin Review, and integrations (Jira, Linear, Azure DevOps, MCP connectors; see the [release notes](https://docs.devin.ai/release-notes/overview)) are mature managed features Waynode does not offer. If your team's bottleneck is a backlog of small, well-scoped tasks and you're comfortable with code executing on Cognition's cloud under consumption billing, Devin is built for exactly that. ## When should you pick Waynode? Pick Waynode if you need the agent to work inside infrastructure you own, whether for code custody, model choice (including local or low-cost models), or cost control, or if you want a durable workspace rather than task-scoped sessions: start a change at your desk, follow the live task from your phone, review the diff, and push, all in the same persistent space. It is also the practical option if you specifically want an open-source, self-hosted alternative in this category; Devin has no equivalent self-serve deployment. For the rest of the category (cloud agents like Claude Code and Codex, and cloud dev environments like Codespaces and Coder), see [/learn](/learn). ## FAQ ### Is there an open-source alternative to Devin? Waynode is an MIT-licensed, self-hosted coding-agent workspace: a persistent Git worktree where an open-source agent engine (pi) works under your control, with chat, autonomous goals, a terminal, and a Git review surface. It covers the "agent works in my repo" loop but not Devin's managed extras like multi-agent orchestration or Devin Review. ### Can Devin be self-hosted? Not through self-serve plans. Devin runs on Cognition's infrastructure via app.devin.ai, Slack/Teams, and a CLI; the [pricing page](https://devin.ai/pricing/) lists a "dedicated deployment option" only under custom-priced Enterprise. ### How much does Devin cost in 2026? As of the April 2026 restructure: Free, Pro $20/mo, Max $200/mo, Teams $80/mo plus $40/mo per developer seat, and custom Enterprise. Plans include usage quotas that refresh automatically, with overages billed at API pricing; Enterprise retains ACU-based billing ([devin.ai/pricing](https://devin.ai/pricing/), [Cognition blog](https://cognition.com/blog/new-self-serve-plans-for-devin)). ### How much does Waynode cost? Self-hosting is free under the MIT license; you pay only your own LLM API and server costs. Waynode Cloud, the managed option, is $39/mo (Starter), $99/mo (Pro), or $249/mo (Team), with a 15-day free trial for new organizations. ### Do Waynode and Devin work with the same repo hosts? Both support GitHub and GitLab. Waynode connects via OAuth to clone repositories into persistent workspaces; Devin integrates for session work and its Devin Review product ([release notes](https://docs.devin.ai/release-notes/overview)). --- --- title: Waynode vs GitHub Codespaces description: How GitHub Codespaces (cloud dev environments for humans) compares to Waynode, a persistent self-hosted workspace where a coding agent works. category: compare slug: waynode-vs-github-codespaces date: 2026-07-12 updated: 2026-07-12 author: Francesco Frapporti keywords: waynode vs github codespaces, github codespaces alternative, self-hosted codespaces alternative cover: /covers/waynode-vs-github-codespaces.png --- ![Waynode vs GitHub Codespaces Cover Image](/covers/waynode-vs-github-codespaces.png) # Waynode vs GitHub Codespaces GitHub Codespaces is a managed cloud development environment: it spins up a container so a human developer can code in VS Code from a browser or desktop, billed per core-hour. Waynode is an open-source (MIT), self-hostable workspace where a coding agent does the work inside a real cloned Git repository, and you review diffs, steer the agent, and push from any device, including a phone. They overlap on "your repo, in the cloud, reachable from anywhere," but they answer different questions: Codespaces asks *where do I type?*; Waynode asks *where does the agent work, and where do I review?* **TL;DR** - **Codespaces** = ephemeral, metered compute for a human editing in VS Code. Stops after 30 minutes of inactivity by default; stopped codespaces are deleted after 30 days by default. - **Waynode** = a durable "space" that is a persistent Git worktree on disk. The agent session, files, branches, and terminal state survive between visits. - In Codespaces, you drive; in Waynode, an agent does (the open-source pi engine, with pi-codex-goal for autonomous goal runs): you chat, assign goals, or drop into a terminal. - Codespaces is GitHub-hosted only. Waynode has a guided Docker Compose installer for your own hardware (free), or Waynode Cloud from $39/mo. - Codespaces bills usage: $0.18/hr for a 2-core machine, $0.07/GB-month storage. Waynode self-host is free (bring your own model keys); Waynode Cloud is a flat monthly plan with token quotas. - They are complementary more than competitive: many teams will keep Codespaces for hands-on-keyboard work and use Waynode for delegated agent work. ## What is GitHub Codespaces? GitHub Codespaces provides on-demand development containers running in GitHub's cloud, configured via `devcontainer.json` and accessed through VS Code (web or desktop), JetBrains IDEs, or SSH. Compute is billed per core-hour: $0.18/hour for a 2-core machine, scaling linearly to $2.88/hour at 32 cores, plus $0.07 per GB-month of storage ([GitHub Codespaces billing docs](https://docs.github.com/en/billing/concepts/product-billing/github-codespaces)). Personal accounts get a free monthly quota (120 core hours and 15 GB-month on GitHub Free, 180 core hours and 20 GB-month on GitHub Pro), while organization and enterprise plans include no free Codespaces quota at all; org usage is paid from the first minute ([billing docs](https://docs.github.com/en/billing/concepts/product-billing/github-codespaces)). Lifecycle is deliberately ephemeral: a codespace stops after 30 minutes of inactivity by default, and stopped codespaces are auto-deleted after 30 days by default ([codespace lifecycle docs](https://docs.github.com/en/codespaces/about-codespaces/the-codespace-lifecycle)). Saved changes in `/workspaces` persist across stop/restart, but changes outside it are cleared on rebuild, and uncommitted work is lost if the codespace is deleted before you push. Storage is billed for as long as the codespace exists, including while it is stopped ([billing docs](https://docs.github.com/en/billing/concepts/product-billing/github-codespaces)). ## What is Waynode? [Waynode](https://github.com/fornace/waynode) is an open-source (MIT), self-hosted coding-agent workspace. Each workspace, called a "space," is a real cloned Git repository on disk: a persistent worktree, not a disposable task container. The agent engine is pi, with pi-codex-goal for autonomous goal-driven runs; you can chat with the agent, hand it a goal, or open a full terminal in the workspace yourself. The Git surface is agent-native: changed files, hunks, diffs, commits, branches, and push live beside the conversation, so "done" means ready for review rather than merely finished running. Sessions persist: conversation, files, branches, and terminal state survive between visits, so you can start at your desk and resume from a phone. Repos connect via GitHub or GitLab OAuth. It runs two ways: self-hosted (free: clone the repo and run `./scripts/self-host.sh setup`, providing an OAuth app and model-provider key during setup; your repos, database, credentials, and LLM keys stay with you) or Waynode Cloud, managed hosting of the same stack with a 15-day free trial. For background, see [/learn](/learn). ## How do they compare? | | GitHub Codespaces | Waynode | |---|---|---| | Primary user | Human developer in an IDE | Coding agent, supervised by a human | | Environment lifetime | Ephemeral; stops after 30 min idle, deleted after 30 days stopped (defaults) ([docs](https://docs.github.com/en/codespaces/about-codespaces/the-codespace-lifecycle)) | Persistent worktree; session, files, branches, terminal state survive between visits | | What a workspace is | Dev container built from `devcontainer.json` | Real cloned Git repository on disk | | Interface | VS Code (web/desktop), JetBrains, SSH | Chat + goals + diffs/commits/push beside the conversation; full terminal; mobile-first web | | Hosting | GitHub's cloud only | Self-host (Docker Compose) or Waynode Cloud | | Source availability | Proprietary service | MIT, open source | | Repo providers | GitHub | GitHub and GitLab (OAuth) | | Pricing model | Usage: $0.18/hr (2-core) to $2.88/hr (32-core) + $0.07/GB-month; free personal quota 120-180 core hrs/mo; no free org quota ([docs](https://docs.github.com/en/billing/concepts/product-billing/github-codespaces)) | Self-host free (BYO model keys); Cloud: Starter $39/mo (3 seats, 3M tokens, 10 GB) · Pro $99/mo · Team $249/mo | | AI assistance | GitHub Copilot via editor extension, a separate product ([docs](https://docs.github.com/en/codespaces/reference/using-github-copilot-in-github-codespaces)) | Built in: the workspace is operated by an agent | | Mobile review | Editing UX is desktop-oriented | Same workspace, session, and diff on a phone | ## Is Waynode a self-hosted Codespaces alternative? Partially, and only for a specific use. If what you want from Codespaces is *a full IDE in the browser for a human* (devcontainer builds, extensions, port forwarding into a live editor), Waynode does not replace that; self-hosted cloud IDE platforms like Coder or Gitpod/Ona are the closer substitutes. What Waynode self-host does give you is the piece Codespaces doesn't offer at all: a durable, self-owned workspace where an agent works in your actual repository, with an operator-owned encryption key and session secret, per-deployment OAuth apps, and your own LLM keys. The default Compose deployment is for a trusted individual or small team and does not provide hardware isolation between its users; a separate KVM/microsandbox deployment is an advanced operator path. There is no per-hour Waynode meter; the cost is your hardware plus your model usage. ## When is Codespaces the better choice? - You are writing and debugging code yourself and want a full VS Code environment with extensions, port forwarding, and devcontainer reproducibility. - You want deep GitHub integration: one-click environments from any GitHub repo or pull request, prebuilds, org-level policies. - Your use is occasional and bursty on a personal account. The free quota (120 core hours/month on GitHub Free) covers a lot of casual use before any bill appears ([docs](https://docs.github.com/en/billing/concepts/product-billing/github-codespaces)). - You have no appetite for infrastructure. There is nothing to operate; GitHub runs everything. ## When is Waynode the better choice? - You want to hand a goal to an agent, close the laptop, and come back to a reviewable branch, not keep an editor session alive. - You review from anywhere: following a live task, reading diffs, steering the agent, and pushing a reviewed change from a phone is the designed-for path, not an afterthought. - You need continuity. The 30-minute idle stop and 30-day deletion defaults that make Codespaces cheap to operate are exactly what you don't want for long-running, resumable agent sessions. A Waynode space just stays. - You want self-hosting and data control: MIT-licensed, runs on your Docker host, GitLab as well as GitHub, and no usage meter. - You want predictable team cost. Since orgs get no free Codespaces quota, per-core-hour billing for a team is open-ended; Waynode Cloud is a flat monthly plan, and self-host is free. Both tools can coexist: Codespaces for the code you write, Waynode for the code you delegate. For adjacent comparisons, see [/compare/waynode-vs-gitpod](/compare/waynode-vs-gitpod) and [/compare/waynode-vs-coder](/compare/waynode-vs-coder). ## FAQ ### Can GitHub Codespaces run coding agents? Codespaces is built for interactive human use; GitHub's own Copilot coding agent runs in its own ephemeral environment powered by GitHub Actions, not in your codespace ([Copilot coding agent docs](https://docs.github.com/en/copilot/concepts/agents/coding-agent/about-coding-agent)). You can run a CLI agent inside a codespace manually, but the environment still stops after 30 minutes of inactivity by default and is deleted after 30 days stopped, so long-lived agent sessions work against its lifecycle model ([lifecycle docs](https://docs.github.com/en/codespaces/about-codespaces/the-codespace-lifecycle)). ### Is Waynode free? Self-hosted Waynode is free and MIT-licensed: clone the repo and run the guided `./scripts/self-host.sh setup` installer. You need Docker Compose v2, an OAuth app, and your own LLM API key. Waynode Cloud, the managed option, starts at $39/month (Starter: 3 seats, 3M agent tokens, 10 GB) with a 15-day free trial. ### Does Codespaces charge while a codespace is stopped? Compute charges stop, but storage is billed for as long as the codespace exists: $0.07 per GB-month until it is deleted ([billing docs](https://docs.github.com/en/billing/concepts/product-billing/github-codespaces)). ### Does Waynode work with GitLab? Yes. Waynode connects to both GitHub and GitLab via OAuth, whereas Codespaces is GitHub-only. ### Do I lose work when a codespace is deleted? Uncommitted changes exist only inside the codespace; if it is deleted (by default, 30 days after it was stopped) without pushing to a remote, that work is lost ([lifecycle docs](https://docs.github.com/en/codespaces/about-codespaces/the-codespace-lifecycle)). Waynode's model avoids this class of loss by making the workspace itself persistent. --- --- title: Waynode vs Gitpod (Ona) description: How Waynode's self-hosted persistent agent workspaces compare with Ona (formerly Gitpod): product, pricing, self-hosting, and the OpenAI acquisition. category: compare slug: waynode-vs-gitpod date: 2026-07-12 updated: 2026-07-12 author: Francesco Frapporti keywords: waynode vs gitpod, gitpod alternative, ona alternative, self-hosted gitpod alternative cover: /covers/waynode-vs-gitpod.png --- ![Waynode vs Gitpod (Ona) Cover Image](/covers/waynode-vs-gitpod.png) # Waynode vs Gitpod (Ona) Gitpod no longer exists as a standalone product: it rebranded to Ona in September 2025, pivoted from cloud dev environments to AI agent orchestration, and OpenAI announced its acquisition of Ona in June 2026 to power long-running Codex tasks. Waynode is an open-source (MIT), self-hostable coding-agent workspace where each workspace is a real cloned Git repository that persists between visits. The practical choice today: Ona if you want managed, ephemeral agent environments inside a large-vendor ecosystem; Waynode if you want a durable agent workspace you run yourself, with your own model keys and no dependence on a vendor's roadmap. **TL;DR** - Gitpod rebranded to [Ona](https://ona.com/stories/gitpod-is-now-ona) on September 2, 2025; the classic Gitpod pay-as-you-go product [was sunset on October 15, 2025](https://ona.com/stories/gitpod-classic-payg-sunset). - [OpenAI announced it is acquiring Ona](https://siliconangle.com/2026/06/11/openai-acquires-ai-agent-orchestration-startup-ona/) on June 11, 2026; the team joins the Codex organization. The standalone platform's long-term future is undisclosed. - Ona pricing: a Free tier (3 parallel environments, up to 4 vCPU, per the [sunset announcement](https://ona.com/stories/gitpod-classic-payg-sunset)), Core from $20/month, Enterprise custom; usage billed in Ona Compute Units ([pricing page](https://ona.com/pricing)). - Ona self-hosting is Enterprise-only (customer-managed VPC on AWS or GCP, custom pricing). Gitpod [ended free self-hosted support in December 2022](https://devclass.com/2022/12/09/gitpod-abandons-self-hosted-product-in-favor-of-dedicated-cloud/). - Waynode is MIT-licensed and self-hosts through a guided Docker Compose installer; workspaces are persistent Git worktrees, not ephemeral containers. Hosted plans start at $39/month. ## What happened to Gitpod? Gitpod spent years as a cloud development environment (CDE) product: one-click, ephemeral workspaces for humans. On September 2, 2025 the company [rebranded to Ona](https://ona.com/stories/gitpod-is-now-ona) and repositioned around three components: **Ona Agents** (software-engineering agents managed through a conversational interface, browser VS Code, or desktop IDEs), **Ona Environments** (ephemeral, sandboxed cloud workspaces configured via `devcontainer.json` and `automations.yml`), and **Ona Guardrails** (enterprise controls: RBAC, SSO/OIDC, command deny lists, audit trails, VPC deployment). The legacy product, "Gitpod Classic," [stopped accepting logins and new environments for pay-as-you-go users on October 15, 2025](https://ona.com/stories/gitpod-classic-payg-sunset). Migration required moving from `.gitpod.yml` to `devcontainer.json` and signing up for a new account at app.ona.com; enterprise customers received custom migration timelines. Then, on June 11, 2026, [OpenAI announced it is acquiring Ona](https://siliconangle.com/2026/06/11/openai-acquires-ai-agent-orchestration-startup-ona/). Terms were not disclosed; OpenAI stated the technology will improve Codex's ability to run tasks that span hours or days, and the Ona team joins OpenAI's Codex team. As of July 2026, ona.com still sells the standalone platform, but its roadmap independence is an open question anyone evaluating it should weigh. ## What is Waynode? [Waynode](https://github.com/fornace/waynode) is an open-source (MIT), self-hosted coding-agent workspace. Each workspace ("space") is a **real cloned Git repository on disk**, a persistent worktree, not a disposable task container. The agent engine is pi (open source), with pi-codex-goal for autonomous goal-driven runs; you can chat with the agent, send it an autonomous goal, or open a full terminal in the workspace. Two properties distinguish it from the CDE lineage Gitpod came from: - The workspace persists. The conversation, files, branches, and terminal state survive between visits. Start at your desk, resume from a phone. Ona Environments are ephemeral by design (Core-plan environments auto-delete after 7 days of inactivity, per the [pricing page](https://ona.com/pricing)). - The Git surface is agent-native. Changed files, hunks, diffs, commits, branches, and push live beside the conversation. "Done" means ready for review, not merely finished running. Waynode connects to GitHub and GitLab via OAuth. Its default Compose deployment assumes trusted users; KVM/microsandbox deployment is a separate advanced operator path. ## Waynode vs Ona: comparison table | | Waynode | Ona (formerly Gitpod) | |---|---|---| | Product category | Persistent coding-agent workspace | Agent orchestration + ephemeral cloud environments | | Workspace model | Persistent Git worktree on disk; sessions survive between visits | Ephemeral, sandboxed environments; 7-day auto-delete on Core ([source](https://ona.com/pricing)) | | License | MIT, fully open source | Core source under AGPL (proprietary license removed after the 2022 self-hosted shutdown); the platform is a commercial service ([source](https://devclass.com/2022/12/09/gitpod-abandons-self-hosted-product-in-favor-of-dedicated-cloud/)) | | Self-hosting | Free: guided Docker Compose setup; OAuth and model key required | Enterprise plan only: customer-managed VPC on AWS/GCP, custom pricing ([source](https://ona.com/pricing)) | | Entry price (hosted) | Starter $39/mo (3 seats, 3M agent tokens, 10 GB) | Core from $20/mo, usage in OCUs (80-2,200 OCUs/mo included; add-ons from $10/40 OCUs) ([source](https://ona.com/pricing)) | | Models | Hosted: fast/reasoning/max tiers (Fornace, GLM, Qwen). Self-host: bring your own keys | Private LLM access with MCP support; model flexibility via AWS Bedrock, Google Vertex, or private APIs ([source](https://ona.com/stories/gitpod-is-now-ona)) | | Workspace setup | OAuth to GitHub or GitLab; workspace is a clone of your repo | Declarative, via `devcontainer.json` and `automations.yml` ([source](https://ona.com/stories/gitpod-is-now-ona)) | | Mobile | Mobile-first web; same workspace/session/diff on a phone; native macOS/iOS clients planned | Browser VS Code and desktop IDE handoff ([source](https://ona.com/stories/gitpod-is-now-ona)) | | Enterprise controls | Operator-owned secrets/encryption keys; per-deployment OAuth apps | SSO/OIDC, audit trails, RBAC, command deny lists (Guardrails) ([source](https://ona.com/stories/gitpod-is-now-ona)) | | Vendor status | Independent open-source project | Acquisition by OpenAI announced June 2026 ([source](https://siliconangle.com/2026/06/11/openai-acquires-ai-agent-orchestration-startup-ona/)) | ## How does pricing actually compare? They meter different things. Ona bills in **Ona Compute Units (OCUs)**, a normalized measure covering both agent token usage and infrastructure: roughly 1 OCU for a small codebase explanation, 1 OCU for one hour of a standard VM, 7 OCUs/hour for a GPU VM. There is a Free tier (3 parallel environments, up to 4 vCPU); Core starts at $20/month with 80-2,200 OCUs included depending on configuration; add-ons cost from $10 per 40 OCUs; Enterprise is custom ([ona.com/pricing](https://ona.com/pricing)). Waynode hosted plans bundle seats, agent tokens, and storage at a flat rate: Starter $39/mo (3 seats, 3M agent tokens/mo, 10 GB), Pro $99/mo (10 seats, 8M tokens, 50 GB), Team $249/mo (25 seats, 20M tokens, 200 GB), with a 15-day free trial for new organizations (5M trial tokens, 2 GB storage, 1 seat). Self-hosting is free under MIT; you pay only your own infrastructure and model API keys. If your workload is bursty compute (big builds, GPU jobs), Ona's usage metering can be efficient. If your workload is sustained agent work on repositories, flat per-seat pricing (or free self-hosting with your own keys) is easier to forecast. ## Is there a self-hosted Gitpod alternative? This is the sharpest difference. Gitpod [dropped its free self-hosted product in December 2022](https://devclass.com/2022/12/09/gitpod-abandons-self-hosted-product-in-favor-of-dedicated-cloud/), and under Ona, self-hosting exists only as an **Enterprise** feature: a deployment inside your VPC on AWS or GCP, at custom pricing ([ona.com/pricing](https://ona.com/pricing)). There is no supported way for an individual or small team to run Ona on their own hardware. Waynode self-hosts by design: clone the [repo](https://github.com/fornace/waynode) and run `./scripts/self-host.sh setup`. The guided installer asks for the public URL, an OAuth app, and a model-provider key, then generates secrets, validates Compose, and starts on loopback. Your repos, database, credentials, LLM keys, and billing stay with you; hosted billing is disabled on self-host. If "self-hosted Gitpod alternative" is your search, note that you are really choosing between two categories: Waynode replaces the *agent workspace* part, not the full CDE feature set (fleet-scale ephemeral environments, standardized dev containers) that Gitpod was known for. ## When is Ona the better choice? - You want fleet-scale ephemeral environments. Ona inherits years of CDE engineering; if you want many parallel, disposable, `devcontainer.json`-standardized environments, that is what the platform is built for. - You need enterprise compliance out of the box. Guardrails ships SSO/OIDC, audit trails, RBAC, and command deny lists ([source](https://ona.com/stories/gitpod-is-now-ona)). Waynode does not claim these; its security posture is operator-owned keys and per-deployment OAuth. - You need big machines on demand. Core supports up to 32 cores / 128 GB RAM / 200 GB disk and GPUs ([source](https://ona.com/pricing)). - Your team is committed to Codex. Post-acquisition, Ona's technology is set to become the execution layer for long-running Codex tasks; if you are on OpenAI's agent stack, that alignment works in your favor. ## When is Waynode the better choice? - You want the workspace to outlive the task. Waynode sessions (conversation, branches, terminal) persist between visits and across devices, versus Ona's ephemeral model. - You want real self-hosting without an enterprise contract: MIT license, Docker Compose, your keys. - You review from a phone. The same workspace, session, and diff render mobile-first; you can follow a live task, steer the agent, and push a reviewed change from a phone. - You want vendor independence. Gitpod users have absorbed a rebrand, a forced migration, a product sunset, and an acquisition announcement within ten months. An MIT-licensed stack you run yourself cannot be sunset out from under you. - You care about the Git surface. Diffs, hunks, commits, and push live beside the agent conversation; the unit of "done" is a reviewable change. See [/learn](/learn) for how Waynode workspaces work. ## FAQ ### Is Gitpod still available? No. Gitpod rebranded to Ona on September 2, 2025, and the classic pay-as-you-go product stopped accepting logins and new environments on October 15, 2025 ([source](https://ona.com/stories/gitpod-classic-payg-sunset)). Enterprise customers had custom migration timelines to the Ona platform. ### Did OpenAI buy Gitpod? OpenAI announced on June 11, 2026 that it is acquiring Ona, the company formerly known as Gitpod, to improve Codex's ability to run tasks spanning hours or days ([source](https://siliconangle.com/2026/06/11/openai-acquires-ai-agent-orchestration-startup-ona/)). Terms were not disclosed, and the standalone Ona platform's long-term roadmap has not been publicly stated. ### Can I self-host Ona for free? No. Ona's self-hosted option (customer-managed VPC on AWS or GCP) is available only on the custom-priced Enterprise plan ([source](https://ona.com/pricing)); Gitpod ended free self-hosted support in December 2022. Waynode self-hosts for free under the MIT license via Docker Compose. ### Is Waynode a drop-in Gitpod replacement? Not exactly. Gitpod/Ona is built around ephemeral, fleet-scale dev environments and enterprise guardrails; Waynode is a persistent agent workspace where each space is a real cloned Git repository with an agent, terminal, and Git review surface. Teams that mainly want an agent working durably in their repo, reviewable from anywhere, fit Waynode; teams that want disposable standardized environments at scale fit Ona. ### How do Waynode and Ona pricing models differ? Ona meters usage in Ona Compute Units covering agent tokens plus infrastructure (Core from $20/month with 80-2,200 OCUs included; add-ons from $10/40 OCUs). Waynode hosted plans are flat: $39, $99, or $249 per month for bundled seats, agent tokens, and storage, and self-hosting costs nothing beyond your own infrastructure and model keys. --- --- title: Waynode vs OpenHands description: How Waynode's persistent Git workspace compares to OpenHands' agent platform: engines, self-hosting, UI, mobile, and pricing, with sources. category: compare slug: waynode-vs-openhands date: 2026-07-12 updated: 2026-07-12 author: Francesco Frapporti keywords: waynode vs openhands, openhands alternative, open source coding agent comparison cover: /covers/waynode-vs-openhands.png --- ![Waynode vs OpenHands Cover Image](/covers/waynode-vs-openhands.png) # Waynode vs OpenHands Waynode and OpenHands are both open-source, self-hostable coding-agent tools, but they are built around different centers of gravity. OpenHands (formerly OpenDevin, by All Hands AI) is an agent platform: a Python agent SDK, a browser workspace called Agent Canvas for managing agents, and a managed cloud. Waynode is a persistent team workspace: each space is a real cloned Git repository on disk where an agent works, and the conversation, branches, diffs, and terminal state survive between visits and devices. **TL;DR** - **OpenHands** = agent framework and control plane. A composable Python SDK that contains the agentic core, a browser-based Agent Canvas UI, a CLI, and OpenHands Cloud with GitHub/GitLab/Bitbucket, Slack, Jira, and Linear integrations ([docs.openhands.dev](https://docs.openhands.dev/)). - **Waynode** = durable place where the agent works. Persistent Git worktrees per workspace, an agent-native Git review surface (files, hunks, commits, branches, push) beside the chat, and mobile-first access to the same session. - Both are open source and self-host with Docker. OpenHands' core is MIT with a separately licensed `enterprise/` directory; Waynode is MIT end to end ([github.com/fornace/waynode](https://github.com/fornace/waynode)). - Engines differ: OpenHands runs its own agent out of the box (and Agent Canvas can drive third-party agents such as Claude Code, Codex, and Gemini); Waynode runs the open-source pi engine with pi-codex-goal for autonomous runs. - Pick OpenHands to build or orchestrate agents programmatically; pick Waynode when you want a long-lived repo workspace your team returns to from any device. ## What is OpenHands? OpenHands is an open-source AI software-development agent that began as OpenDevin, an open-source homage to Cognition's Devin; the project was renamed OpenHands and its maintainers founded All Hands AI in 2024 ([openhands.dev/blog](https://www.openhands.dev/blog/one-year-of-openhands-a-journey-of-open-source-ai-development)). As of July 2026 the GitHub repository has around 80.5k stars and describes itself as "the self-hosted developer control center for coding agents and automations" ([github.com/OpenHands/OpenHands](https://github.com/OpenHands/OpenHands)). The product today has several layers ([docs.openhands.dev](https://docs.openhands.dev/)): - Agent SDK: a composable Python library containing the agentic core; agents are defined in code and run locally or at scale. - Agent Canvas: a browser workspace started with a single `agent-canvas` command (npm or Docker). It runs the OpenHands agent out of the box and can also drive third-party agents such as Claude Code, Codex, and Gemini via the Agent-Client Protocol ([github.com/OpenHands/OpenHands](https://github.com/OpenHands/OpenHands)). - CLI and legacy GUI: a terminal interface and an older Docker-based GUI. - OpenHands Cloud: managed hosting with deeper GitHub, GitLab, and Bitbucket integrations plus Slack, Jira, and Linear, multi-user support, and collaboration tools. Sandboxed execution uses Docker; the Docker sandbox is the default and recommended isolation model for most users ([docs.openhands.dev/openhands/usage/sandboxes/docker](https://docs.openhands.dev/openhands/usage/sandboxes/docker)). ## What is Waynode? Waynode is an open-source (MIT), self-hosted coding-agent workspace ([github.com/fornace/waynode](https://github.com/fornace/waynode)). Each workspace ("space") is a real cloned Git repository on disk, a persistent worktree rather than a disposable task container. The agent engine is pi, with pi-codex-goal for autonomous goal-driven runs; you can chat with the agent, send it an autonomous goal, or open a full terminal in the workspace. Its defining features: - An agent-native Git surface: changed files, hunks, diffs, commits, branches, and push live beside the conversation. "Done" means ready for review, not merely finished running. - Persistent sessions: conversation, files, branches, and terminal state survive between visits; start at your desk, resume from any device. - Mobile-first: the same workspace, session, and diff on a phone; macOS and iOS native clients are planned (a native app exists in the repo). - GitHub and GitLab repo providers via OAuth. See [/learn](/learn) for the full product overview. ## How do they compare? | | Waynode | OpenHands | |---|---|---| | Category | Persistent coding-agent workspace | Agent SDK + control plane + cloud | | License | MIT (entire stack) | MIT core; `enterprise/` directory separately licensed ([docs](https://docs.openhands.dev/)) | | Agent engine | pi + pi-codex-goal (open source) | OpenHands agent (Python SDK); Agent Canvas also drives Claude Code, Codex, Gemini ([GitHub](https://github.com/OpenHands/OpenHands)) | | Workspace model | Persistent cloned Git repo per space; state survives visits | Docker-sandboxed agent runs; Cloud adds multi-user support ([docs](https://docs.openhands.dev/)) | | Git surface | Files, hunks, diffs, commits, branches, push beside the chat | GitHub, GitLab, Bitbucket integrations in Cloud ([docs](https://docs.openhands.dev/)) | | Terminal | Full terminal in the workspace | CLI (terminal interface) | | Mobile | Mobile-first web; native macOS/iOS clients planned | Cloud reachable from a browser; no mobile-specific product listed ([pricing](https://www.openhands.dev/pricing)) | | Self-host | Guided Docker Compose installer, free | `agent-canvas` via npm or Docker, free (MIT core) | | Repo providers | GitHub, GitLab (OAuth) | GitHub, GitLab, Bitbucket; plus Slack, Jira, Linear ([docs](https://docs.openhands.dev/)) | | Hosted pricing | Starter $39/mo · Pro $99/mo · Team $249/mo; 15-day trial | Individual free (1 user, 10 daily conversations, LLM at cost or BYOK); Enterprise custom ([pricing](https://www.openhands.dev/pricing)) | | Models | Hosted tiers (Fornace models, GLM, Qwen); self-host BYOK | Model-agnostic; BYOK or at-cost provider with no markup ([pricing](https://www.openhands.dev/pricing)) | ## Which agent engine do you get? OpenHands ships its own agent as a Python SDK (the same agentic core powers the CLI, Canvas, and Cloud), and Agent Canvas can additionally orchestrate third-party agents such as Claude Code, Codex, and Gemini via the Agent-Client Protocol ([github.com/OpenHands/OpenHands](https://github.com/OpenHands/OpenHands)). If you want to define custom agents in code, evaluate them, or build automations on top of an agent framework, this is OpenHands' strongest territory. Waynode does not ask you to build agents. It runs pi (open source) as the engine and pi-codex-goal for autonomous runs, and puts its effort into the surface around the agent: the persistent repo, the review-grade Git panel, the terminal, and session continuity. You configure model keys (self-host) or pick from hosted fast/reasoning/max tiers (Waynode Cloud) rather than programming agent behavior. ## How does self-hosting differ? Both self-host for free with Docker. - Waynode: clone the repo and run `./scripts/self-host.sh setup`. The guided installer requires Docker Compose v2, an OAuth app, and a supported model-provider key; it generates the server secrets and starts on loopback by default. Your repos, database, credentials, LLM keys, and billing stay with you; hosted billing is disabled on self-host. The default Compose deployment does not isolate trusted users from one another; KVM/microsandbox deployment is a separate advanced operator path. - OpenHands: `npm install -g @openhands/agent-canvas` or a single `docker run` of the agent-canvas image, serving a web UI on localhost:8000 ([github.com/OpenHands/OpenHands](https://github.com/OpenHands/OpenHands)). Sandboxed execution runs in Docker, the default and recommended isolation model ([docs.openhands.dev/openhands/usage/sandboxes/docker](https://docs.openhands.dev/openhands/usage/sandboxes/docker)). One licensing nuance: OpenHands' work is MIT-licensed except for the repository's `enterprise/` directory, which carries a separate license requiring purchase for use beyond one month ([docs.openhands.dev](https://docs.openhands.dev/)). Waynode's entire repository is MIT. ## What do the hosted offerings cost? OpenHands Cloud has a free Individual plan (one user, up to 10 daily conversations, bring your own LLM key or use OpenHands' provider at cost with no markup) and a custom-priced Enterprise plan with SAML/SSO, SaaS or self-hosted-in-your-VPC deployment, and unlimited concurrent conversations ([openhands.dev/pricing](https://www.openhands.dev/pricing)). There is no published mid-tier price between free and Enterprise as of July 2026. Waynode Cloud is managed hosting of the same open-source stack: Starter $39/mo (3 seats, 3M agent tokens/mo, 10 GB), Pro $99/mo (10 seats, 8M tokens, 50 GB), Team $249/mo (25 seats, 20M tokens, 200 GB), with a 15-day free trial for new organizations (5M trial tokens, 2 GB storage, 1 seat). The models differ: OpenHands passes LLM cost through (or you bring keys); Waynode bundles token allowances into flat seat-based plans. ## When should you pick each? **Pick OpenHands if:** - You want to build, customize, or evaluate agents programmatically with a Python SDK. - You need Bitbucket, Jira, Slack, or Linear integrations, or you want one canvas to manage multiple third-party agents (Claude Code, Codex, Gemini). - A free hosted tier with pass-through LLM pricing fits how you work. **Pick Waynode if:** - You want the agent working in a real, persistent clone of your repository rather than disposable sandboxes, with branches and terminal state intact when you come back. - Review is the bottleneck: you want diffs, hunks, commits, and push next to the conversation, on desktop or phone. - You want a small-team hosted plan with predictable flat pricing, or a fully MIT stack with no separately licensed directories. The honest summary: OpenHands is the more mature agent platform with a larger ecosystem; Waynode is the more opinionated workspace around one agent and one repo. Teams that mostly need "a durable place where the agent works on our code, reviewable from anywhere" get that from Waynode with less surface area. Teams building agentic automations get more from OpenHands. For adjacent comparisons, see [/compare/waynode-vs-devin](/compare/waynode-vs-devin) and the self-hosting walkthrough in [/guides/self-host-coding-agent-docker](/guides/self-host-coding-agent-docker). ## FAQ ### Is OpenHands the same as OpenDevin? Yes. The project started as OpenDevin, an open-source homage to Cognition's Devin, and was renamed OpenHands; its maintainers founded All Hands AI in 2024 ([source](https://www.openhands.dev/blog/one-year-of-openhands-a-journey-of-open-source-ai-development)). The codebase and community carried over. ### Are both Waynode and OpenHands free to self-host? Yes. Waynode is MIT-licensed end to end and includes a guided Docker Compose installer. OpenHands' core (including the `openhands` and `agent-server` Docker images) is MIT and runs via npm or Docker, though its `enterprise/` directory is separately licensed ([docs.openhands.dev](https://docs.openhands.dev/)). ### Can I use OpenHands or Waynode from my phone? OpenHands Cloud is reachable from a mobile browser, but no mobile-specific product is listed ([pricing page](https://www.openhands.dev/pricing)). Waynode is mobile-first by design: the same workspace, session, and diff render on a phone, and native macOS/iOS clients are planned. ### Which supports more Git providers? OpenHands Cloud integrates GitHub, GitLab, and Bitbucket, plus Slack, Jira, and Linear ([docs.openhands.dev](https://docs.openhands.dev/)). Waynode supports GitHub and GitLab via OAuth, with a deeper in-workspace Git surface (hunks, commits, branches, push beside the chat). ### Does Waynode use the OpenHands agent? No. Waynode runs the open-source pi engine, with pi-codex-goal for autonomous goal-driven runs. OpenHands ships its own agent via its Python SDK. --- --- title: "Self-hosted vs cloud coding agents: how to choose" description: A decision framework for choosing between self-hosted and cloud coding agents, covering data control, cost structure, maintenance, and compliance. category: guides slug: self-hosted-vs-cloud-coding-agents date: 2026-07-12 updated: 2026-07-12 author: Francesco Frapporti keywords: self-hosted vs cloud ai coding agent, should i self-host coding agent, coding agent data privacy cover: /covers/self-hosted-vs-cloud-coding-agents.png --- !["Self-hosted vs cloud coding agents: how to choose" Cover Image](/covers/self-hosted-vs-cloud-coding-agents.png) # Self-hosted vs cloud coding agents: how to choose Choose a cloud coding agent when you want someone else operating the infrastructure and a shorter adoption path; choose a self-hosted agent when your code, credentials, and LLM spend must stay under your control, and you can accept the operational work that comes with running it. The decision is rarely about agent quality (most self-hostable agents call the same frontier models via API) and mostly about where your repository is cloned, who holds the keys, and how you pay for tokens. **TL;DR** - **Cloud agents** (OpenAI Codex cloud tasks, Devin, Cursor cloud agents, GitHub Copilot coding agent) clone your repo into vendor-operated sandboxes. Fast to adopt, subscription-priced, but your source and Git credentials transit third-party infrastructure. - **Self-hosted agents** run on hardware you control. Your repo clone, database, and stored credentials stay in your deployment, while inference requests go directly to the model provider you choose; you patch, back up, and secure the deployment yourself. - Cost models differ structurally: cloud is subscription plus metered credits; self-hosted is infrastructure cost plus raw API token prices with no markup. - Compliance-constrained teams (regulated industries, client-code agencies, air-gapped environments) usually need self-hosting or a vendor VPC deployment. - Some tools offer both modes: Devin has a VPC enterprise option, and open-source workspaces like [Waynode](https://github.com/fornace/waynode) can be self-hosted free or used as managed hosting. ## What is the actual difference? A **cloud coding agent** is a managed service: the vendor clones your repository into a sandbox on their infrastructure, runs the agent there, and returns a pull request. You grant it access to your GitHub or GitLab account, and the vendor operates everything: compute, secrets, model routing, updates. A **self-hosted coding agent** runs the same loop on machines you control: a workstation, an on-prem server, or your own cloud account. The repository is cloned to your disk, the agent process runs under your OS, and model calls go directly from your network to the LLM provider (or to a local model). Nothing about your code or credentials passes through the agent vendor. Terminal-based agents like Claude Code blur the line: the agent process runs locally on your machine, but code context is sent to Anthropic's API for inference, and its subscription plans (Pro $20/mo, Max $100-$200/mo, per [claude.com/pricing](https://claude.com/pricing)) bill through Anthropic. "Self-hosted" in the strict sense means the whole workspace (repo storage, session state, execution sandbox) lives on your infrastructure, with only inference (optionally) leaving it. ## Comparison: self-hosted vs cloud coding agents | Dimension | Cloud agent | Self-hosted agent | |---|---|---| | **Where your repo is cloned** | Vendor-operated sandbox/VM | Your own disk or server | | **Git credentials** | OAuth grant held by vendor | Stay in your deployment | | **LLM keys and billing** | Vendor's keys; you buy credits/subscription | Your keys; you pay API list price | | **Setup effort** | Minutes (sign in, connect repo) | Hours (Docker/compose, env config, OAuth apps) | | **Maintenance** | None (vendor updates) | Yours: updates, backups, TLS, secrets | | **Model choice** | Vendor's menu, sometimes locked | Any provider or local models | | **Cost structure** | Subscription + metered credits | Infra cost + raw token spend | | **Compliance/data residency** | Vendor's certifications and DPA | Whatever you enforce; data never leaves | | **Failure mode** | Vendor outage/policy change | Your ops mistake | ## Who sees your code with a cloud coding agent? With any cloud agent, at minimum two parties process your source: the agent vendor (whose sandbox clones the repo) and the model provider (who receives code context in prompts). Sometimes they are the same company, sometimes not. Cursor's cloud agents run on Cursor infrastructure but call third-party frontier models; its privacy mode commits that "we will not train on your data" with contractual controls on model providers ([cursor.com/security](https://cursor.com/security)). OpenAI states there is no training on business data by default for ChatGPT Business/Enterprise plans that include Codex ([Codex pricing docs](https://developers.openai.com/codex/pricing)). Training opt-outs are not the whole story. The practical exposure surface also includes: - The OAuth token that lets the agent push branches is held and exercised by the vendor. - `.env` files, internal URLs, and other infrastructure details in the repo or environment are visible to the sandbox. - Prompts, diffs, and terminal output may be retained per the vendor's policy, which you should read rather than assume. Self-hosting collapses this surface to one party: the model provider you choose to send prompts to. If you run local models, it collapses to zero. This is the core answer to "should I self-host a coding agent": self-host when reducing that surface is a requirement, not a preference. ## How do the cost structures compare? Cloud agents are subscription-first with metered usage on top. Current published pricing (July 2026): | Product | Entry price | Metering | |---|---|---| | OpenAI Codex (via ChatGPT) | Free tier; Plus $20/mo; Pro from $100/mo; Business $20/user/mo annual | Token-based credits since April 2026 ([source](https://developers.openai.com/codex/pricing)) | | Devin (Cognition) | Free tier; Pro $20/mo; Max $200/mo; Teams $80/mo + $40/seat | Consumption-based on model and task; Enterprise adds VPC deployment ([source](https://devin.ai/pricing/)) | | Cursor | Individual from $20/mo; Teams $40/user/mo | Cloud agents bill usage-based on top of plans ([source](https://cursor.com/pricing)) | | GitHub Copilot coding agent | Pro $10/mo ($15 credits); Pro+ $39/mo ($70); Max $100/mo ($200) | AI Credits, 1 credit = $0.01; agent on paid plans ([source](https://github.com/features/copilot/plans)) | | Claude Code | Pro $20/mo; Max $100-$200/mo | Plan rate limits; API pay-as-you-go alternative ([source](https://claude.com/pricing)) | Self-hosting inverts the structure: the software is often free (open source), and you pay two real costs: infrastructure (a VPS or spare machine running Docker is typically $5-$40/mo, or effectively zero on hardware you own) and model API usage at list price with no intermediary margin. For heavy agent use, BYO keys is usually cheaper per token than vendor credits; for light use, a flat subscription can be cheaper than the discipline of managing keys. There is also an unpriced cost: your time operating the deployment. ## What maintenance does self-hosting actually require? Be honest about the burden before choosing it: - Initial setup means cloning, environment configuration, creating GitHub/GitLab OAuth apps, and DNS/TLS if you expose it beyond localhost. Budget an afternoon, not five minutes. - You pull new images and migrate when releases ship; nobody does it for you. - Workspace state, database, and secrets are yours to back up and restore. - Session secrets and encryption keys are operator-owned: you control them and you have to protect them. Sandboxing agent execution (e.g. microVMs where KVM is available) is on you to enable. If your team has no one willing to own this, a managed offering is the more truthful choice even if self-hosting looks free on paper. ## When should you choose each? **Choose a cloud agent when:** - You want to try agentic coding today with zero infrastructure work. - Your code is not subject to residency, client-confidentiality, or regulatory constraints. - Usage is light enough that a flat subscription beats managing API keys. - You value vendor-managed sandboxing and updates over control. **Choose self-hosted when:** - Source code, credentials, or client IP must not transit third-party infrastructure. - You need model freedom: a specific provider, a cheaper model, or local inference. - Agent usage is heavy enough that raw API pricing beats credit markups. - Compliance requires you to point at exactly where data lives (self-hosting makes the answer "our server"). **Consider a hybrid** when different repos have different sensitivity: cloud agents for open-source and low-risk work, self-hosted for the crown jewels. Devin's enterprise VPC option ([devin.ai/pricing](https://devin.ai/pricing/)) is one vendor-managed version of this. ## Where does Waynode fit? [Waynode](https://github.com/fornace/waynode) is one example of a tool built to offer both modes with the same open-source (MIT) stack. Self-hosted, it uses a guided Docker Compose installer that collects the OAuth and model-provider configuration, generates server secrets, validates Compose, and starts on loopback; each workspace is a real cloned Git repository on disk, while your database and LLM keys stay with you. [Waynode Cloud](/learn) operates the server, updates, encrypted secrets, and Stripe billing, from $39/mo (Starter: 3 seats, 3M agent tokens/mo, 10 GB) up to $249/mo (Team: 25 seats, 20M tokens, 200 GB), with a 15-day free trial for new organizations. Interactive terminal access is currently self-hosted only. Because both modes run the same open-source stack, teams can start managed and move to self-hosting (or the reverse) without changing tools. It does not currently offer SSO or compliance certifications, so enterprises with those requirements should evaluate accordingly. Feature-level comparisons against specific cloud agents are collected at [/learn](/learn). ## FAQ ### Is a self-hosted coding agent more private than a cloud one? Structurally yes: self-hosting removes the agent vendor from the data path, leaving only the model provider you send prompts to (or no one, with local models). A cloud agent's privacy depends on its retention, training, and access policies, which vary by vendor and plan. ### Is self-hosting a coding agent cheaper? For heavy usage, usually: you pay raw API token prices plus modest infrastructure costs instead of subscription credits with margin. For light or occasional use, a $10-$20/mo cloud subscription is often cheaper than the time spent operating your own deployment. ### Can I use frontier models like GPT or Claude with a self-hosted agent? Yes. Self-hosted agents typically use bring-your-own API keys, so you can point them at OpenAI, Anthropic, or any provider; code execution and repository storage stay local while only inference requests leave your network. ### Do cloud coding agents train on my code? Major vendors default to no training for business plans: OpenAI states no training on ChatGPT Business/Enterprise data by default, and Cursor's privacy mode commits to no training with contractual controls on model providers. Check the specific plan's policy; consumer tiers can differ. ### What is the minimum setup to self-host a coding agent workspace? For Waynode: install Docker Compose v2, create a GitHub or GitLab OAuth app, get a supported model-provider key, clone the repo, and run `./scripts/self-host.sh setup`. The installer writes and validates the deployment configuration and starts on loopback; remote access still needs a domain, HTTPS reverse proxy, and matching OAuth callbacks. Comparable open-source tools have similar Docker-based setups; allow time for OAuth and production network configuration rather than treating self-hosting as zero setup. --- --- title: How to self-host a coding agent with Docker description: Step-by-step guide to running a self-hosted AI coding agent on your own server with Docker Compose, HTTPS, OAuth, and your own LLM keys. category: guides slug: self-host-coding-agent-docker date: 2026-07-12 updated: 2026-07-14 author: Francesco Frapporti keywords: self-host coding agent, self-hosted ai coding assistant docker, run coding agent on your own server cover: /covers/self-host-coding-agent-docker.png --- ![How to self-host a coding agent with Docker Cover Image](/covers/self-host-coding-agent-docker.png) # How to self-host a coding agent with Docker Self-hosting a coding agent means running the agent's server, workspaces, and credentials on infrastructure you control rather than an agent vendor's SaaS. If you use a hosted model API, prompts and selected code context still go directly to that provider. A Docker-packaged agent workspace such as [Waynode](https://github.com/fornace/waynode) (open source, MIT) still needs real operator configuration: a Git provider OAuth app, model-provider credentials, HTTPS for remote access, and a backup plan. Waynode's guided installer handles the local secrets and Docker Compose validation; this guide walks through the remaining decisions end to end. The pattern (container + secrets + OAuth + reverse proxy + your own model keys) applies to any self-hosted AI coding assistant. **TL;DR** - Prerequisites: a Linux host with Docker Engine and Docker Compose v2, a GitHub or GitLab OAuth app, a supported model-provider key, and a domain if you want remote/mobile access. - Install: `git clone` → `./scripts/self-host.sh setup`. The interactive installer generates the server secrets, records OAuth and model configuration, validates Compose, and starts on loopback. - Expose it safely with a reverse proxy (Caddy or nginx) terminating HTTPS, and set `APP_URL` to the public URL so OAuth callbacks work. - You bring your own model key; Waynode's hosted billing and usage limits are disabled in self-host mode, while your model provider bills its API usage directly. - Keep `.env` out of Git and protect it as a credential; never expose the app over plain HTTP beyond localhost. ## What do you need before you start? Four things: 1. A Linux host with Docker Engine and Docker Compose v2: a home server or a VPS. A coding agent workspace clones real Git repositories to disk, so budget disk space for the repos you plan to work on plus the container image and session history. 2. A Git provider OAuth app. Waynode authenticates users and clones repositories via GitHub or GitLab OAuth. You create the OAuth app in your own GitHub/GitLab account, so tokens are issued to *your* deployment, not to a vendor. 3. An LLM API key and model ID. The guided path supports Anthropic, OpenAI, Google Gemini, or OpenRouter. The agent engine is pi (open source), with pi-codex-goal for autonomous goal-driven runs. 4. Optionally, a domain name. Only needed if you want HTTPS access from outside the machine, which is most of the point if you want to steer the agent from a phone. The default Compose deployment is intended for a trusted individual or small team. Agent commands run inside the Waynode container, whose data volume contains every worktree; it does not provide hardware isolation between users. The separate KVM/microsandbox deployment is an advanced operator path, not a property of the default installer. ## How do you install the agent with Docker Compose? Clone the repository and run the interactive installer: ```bash git clone https://github.com/fornace/waynode.git cd waynode ./scripts/self-host.sh setup ``` Before running it, create a GitHub or GitLab OAuth application and have a supported provider key plus provider-local model ID ready. The installer prints the exact OAuth callbacks, generates different 256-bit session and encryption secrets, writes a mode-`0600` `.env`, validates Compose, builds the service, and waits for its auth endpoint to report healthy. It refuses to overwrite an existing `.env`. With the default local URL, the app comes up on `http://localhost:3000`. The Compose file defines a single service with a named volume for persistent data: workspaces, database, and terminal/session state live in that volume, which is what makes sessions durable across container restarts. Before updating, record the current commit and take a stop-consistent data backup plus a protected copy of `.env`. Then use `git pull --ff-only`, `docker compose up -d --build`, and `./scripts/self-host.sh check`. The data volume is not replaced by a normal rebuild, but database migrations may make rollback require restoring the pre-upgrade archive. See the [complete self-hosting runbook](https://github.com/fornace/waynode/blob/main/docs/SELF-HOSTING.md). ## Which environment variables matter? The installer writes `.env`; manual installation remains available through `.env.example`. The security-relevant variables are: | Variable | Purpose | How to set it | |---|---|---| | `SESSION_SECRET` | Signs session cookies | `openssl rand -hex 32` (random, unique per deployment) | | `ENCRYPTION_KEY` | Encrypts stored secrets at rest | `openssl rand -hex 32` (different from `SESSION_SECRET`) | | `APP_URL` | Public base URL; used for OAuth callbacks | `http://localhost:3000` locally, `https://agent.example.com` in production | | `GITHUB_CLIENT_ID` / `GITHUB_CLIENT_SECRET` | GitHub OAuth app | Created in GitHub → Settings → Developer settings → OAuth Apps | | `GITLAB_CLIENT_ID` / `GITLAB_CLIENT_SECRET` / `GITLAB_BASE_URL` | GitLab OAuth (gitlab.com or self-managed) | Created in GitLab → User Settings → Applications | | `PI_DEFAULT_PROVIDER` / `PI_DEFAULT_MODEL` | Which LLM the agent uses by default | Your provider and model id; you supply the API key | | `PI_PROVIDER_API_KEY` | One-time first-boot provider credential | The installer encrypts it into Waynode's global secret vault | Two rules that prevent most self-hosting incidents: - Never reuse or commit the secrets. If `SESSION_SECRET` leaks, sessions can be forged; if `ENCRYPTION_KEY` leaks alongside a database copy, stored credentials can be decrypted. Keep `.env` out of Git and, for production, load these from a secret manager. - Do not set `WAYNODE_DEPLOYMENT=hosted` or enable hosted Stripe variables. The self-host installer writes `WAYNODE_DEPLOYMENT=self-hosted` and refuses the hosted value; hosted billing, payment collection, and Waynode usage limits stay disabled. ## How do you set up GitHub or GitLab OAuth? Create an OAuth app in the provider, pointing back at your deployment: - GitHub: Settings → Developer settings → OAuth Apps → New OAuth App. Set the callback URL to `${APP_URL}/auth/github/callback`. - GitLab: User Settings → Applications. Set the redirect URI to `${APP_URL}/auth/gitlab/callback`. For self-managed GitLab, also set `GITLAB_BASE_URL`. The callback URL must match `APP_URL` exactly: scheme, host, and port. This is the most common setup failure: the app works on localhost, then OAuth breaks after moving behind a domain because the OAuth app still points at `http://localhost:3000`. When you add HTTPS (next section), update both `APP_URL` and the provider-side callback URL, then restart the container. ## How do you add a reverse proxy and HTTPS? Keep the app off the public interface and put a TLS-terminating proxy in front. The default Compose file binds `127.0.0.1:3000`, so only a proxy on the same host can reach it. Set `WAYNODE_BIND_ADDRESS=0.0.0.0` only when another host must reach the Docker port and a firewall restricts access. With [Caddy](https://caddyserver.com/) the whole proxy config is: ``` agent.example.com { reverse_proxy localhost:3000 } ``` Caddy provisions and renews Let's Encrypt certificates automatically. With nginx, use a standard `proxy_pass http://127.0.0.1:3000` server block plus certbot, and make sure WebSocket upgrade headers (`Upgrade`, `Connection`) are forwarded, since the live agent stream and the in-browser terminal depend on them. Set `APP_URL=https://agent.example.com` during setup so the printed OAuth callbacks are correct. If the URL changes later, update `.env`, update the provider-side callback, and restart with `docker compose up -d`. From this point the same workspace, session, and diff view are reachable from any device. Waynode's UI is mobile-first, so following a running task or reviewing changed files from a phone works against your own server. Do not expose port 3000 directly to the internet. A coding agent has your repo credentials and can execute code; plain HTTP plus a public port is the one configuration to categorically avoid. ## How do you bring your own LLM keys? Self-hosting means the model relationship is also yours: you pay your provider directly at API rates, with no Waynode per-seat markup or hosted token quota. During setup, choose Anthropic, OpenAI, Google Gemini, or OpenRouter; enter a provider-local model ID and the corresponding API key. On first boot, Waynode maps `PI_PROVIDER_API_KEY` to the provider's exact key name, encrypts it into the global secret vault, and removes the bootstrap names from the live process before starting an agent. Later restarts do not overwrite the encrypted value. The bootstrap value remains in the root-readable `.env` for disaster recovery. After a verified prompt, you may blank it if the key is stored elsewhere; later rotation and worktree-scoped overrides belong in Settings → Secrets. The installer validates that configuration is present, but only a real prompt can prove the model ID and credential entitlement. This is the main economic difference from managed agent products: your spend tracks actual usage on your provider bill. The trade-off is that you own capacity planning and cost monitoring yourself: there is no built-in quota to stop a runaway autonomous run except your provider's own limits. ## What are the security basics for a self-hosted coding agent? A minimal checklist: - Let the installer generate different `SESSION_SECRET` and `ENCRYPTION_KEY` values; store a protected copy of `.env`; never commit it, OAuth client secrets, or provider tokens. - Use HTTPS at the reverse proxy for anything beyond localhost. OAuth flows and repo tokens must never cross plain HTTP. - An agent workspace holds cloned repos and can run commands. Treat every invited user and repository as trusted on the default Compose deployment; run it on a dedicated host or VM where possible. - Grant the OAuth app only the scopes your provider flow requires, and keep it pointed at your deployment's exact callback URL. - Back up with `./scripts/self-host.sh backup`, keep `.env` separately, copy both off-host, and test restores. The helper stops the service for a consistent archive but does not encrypt, upload, rotate, or validate it for you. ## Does this recipe work for other self-hosted coding agents? Broadly, yes. Other open-source agents follow the same shape: a container, a port, mounted persistent state, and your own model key. [OpenHands](https://github.com/OpenHands/OpenHands), for example, runs its GUI from a single `docker run` of `ghcr.io/openhands/agent-canvas` on port 8000 with `~/.openhands` and a projects directory mounted, and supports bring-your-own-model configuration ([OpenHands repository](https://github.com/OpenHands/OpenHands), retrieved July 2026). The architectural difference to check when choosing a tool is what a "workspace" is. OpenHands mounts a projects directory into task sandboxes; Waynode's unit is a persistent cloned Git repository: a real worktree with its own branches, terminal state, and an agent-native Git surface (diffs, hunks, commits, push) beside the conversation, all of which survive between visits. If your workflow is "start an agent task at your desk, review and push from your phone later," that persistence is the feature to select for. For a comparison of self-hosting versus managed cloud agents, see [/learn](/learn). ## FAQ ### How much does it cost to self-host a coding agent? The software is free: Waynode is MIT-licensed, with hosted billing and Waynode usage limits disabled on self-hosted installs. Your costs are the server (disk scales with your repos) and your LLM provider's API usage, paid directly at provider rates. ### Can I run a self-hosted coding agent without a domain name? Yes, on `http://localhost:3000` with `APP_URL` left at its default, which is fine for a single machine. You need a domain and HTTPS only for remote or mobile access, and OAuth callbacks must then match the public URL exactly. ### What happens to my code and API keys when I self-host? Repositories and stored credentials stay on your infrastructure. Repositories are cloned to a Docker volume on your host, and credentials are encrypted at rest with your own `ENCRYPTION_KEY`. LLM requests go directly from your server to the model provider you configured, so that provider receives the prompts and selected code context needed for inference; Waynode is not an intermediary in that path. ### Do I need a GPU to self-host a coding agent? No. The agent workspace itself is a lightweight web application; the language model runs at your API provider. A GPU only becomes relevant if you separately choose to serve a local model and point the agent's provider configuration at it. ### What is the difference between self-hosting Waynode and using Waynode Cloud? Same open-source stack. Self-host is free and everything (repos, database, keys, billing) stays with you; Waynode Cloud operates the server, updates, encrypted secrets, and Stripe billing from $39/mo (Starter: 3 seats, 3M agent tokens/mo, 10 GB), with a 15-day free trial for new organizations. Interactive terminal access is currently self-hosted only. --- --- title: Open-source Devin alternatives in 2026 description: Seven open-source and self-hostable alternatives to Devin in 2026, compared by license, hosting model, interface, and agent engine. category: guides slug: open-source-devin-alternatives date: 2026-07-12 updated: 2026-07-12 author: Francesco Frapporti keywords: open source devin alternative, self-hosted devin, devin alternatives 2026, free ai software engineer cover: /covers/open-source-devin-alternatives.png --- ![Open-source Devin alternatives in 2026 Cover Image](/covers/open-source-devin-alternatives.png) # Open-source Devin alternatives in 2026 The closest open-source equivalents to Devin in 2026 are OpenHands (autonomous agent platform, MIT core), Waynode (self-hosted agent workspace, MIT), and a set of bring-your-own-key agents (OpenCode, Goose, Cline, Aider, and mini-SWE-agent) that run on your own machine with any model. None is a drop-in Devin clone; each covers a different slice of "an AI engineer that works while you don't", and all of them let you keep code, credentials, and model spend under your own control. **TL;DR** - [OpenHands](https://github.com/OpenHands/OpenHands) is the most direct open-source Devin analogue: an autonomous agent with a web UI, self-hosted via Docker, ~80k GitHub stars. - [Waynode](https://github.com/fornace/waynode) is not an autonomous-engineer clone; it is a self-hosted workspace where an agent works in a real cloned repo you can return to from any device, including a phone. - [OpenCode](https://opencode.ai/), [Goose](https://github.com/aaif-goose/goose), [Cline](https://cline.bot/), and [Aider](https://aider.chat/) are local, developer-driven agents: free software, you pay only for model tokens. - [mini-SWE-agent](https://github.com/SWE-agent/mini-swe-agent) is the research-grade option: ~100 lines of agent code scoring >74% on SWE-bench Verified. - Devin's self-serve plans now run Free, Pro $20/mo, Max $200/mo, and Teams $80/mo plus $40 per developer seat, with auto-refreshing usage quotas and API-priced overages ([devin.ai/pricing](https://devin.ai/pricing/)). The open-source case is control and cost transparency more than price. ## What does "Devin alternative" actually mean? Devin is a hosted autonomous software engineer: you give it a task, it plans, edits, runs tests, and opens a pull request inside Cognition's cloud. Billing is quota-based: each paid plan includes a usage allowance that refreshes automatically, with overages purchased at API pricing ([devin.ai/pricing](https://devin.ai/pricing/)); the earlier ACU-denominated Core and Team plans were retired in April 2026 ([Cognition announcement](https://cognition.com/blog/new-self-serve-plans-for-devin)). An open-source alternative can replace different parts of that: - The autonomous loop: an agent that takes an issue and drives it to a PR (OpenHands, mini-SWE-agent). - The workspace: a durable place where agent runs, diffs, branches, and terminal state live and persist (Waynode). - The pair-programming layer: an agent you steer interactively in a terminal or editor (OpenCode, Goose, Cline, Aider). Deciding which slice you need matters more than any ranking. The list below is ordered by how directly each tool substitutes for Devin's core promise. For a head-to-head with Devin itself, see [/compare/waynode-vs-devin](/compare/waynode-vs-devin). ## Comparison table | Tool | License | Hosting | Interface | Engine / models | |---|---|---|---|---| | [OpenHands](https://github.com/OpenHands/OpenHands) | MIT (core); enterprise Helm chart under Polyform Free Trial | Self-host (Docker) or OpenHands Cloud | Web GUI, CLI, TUI | Model-agnostic; runs OpenHands, Claude Code, Codex, Gemini agents | | [Waynode](https://github.com/fornace/waynode) | MIT | Self-host (`docker compose`) or Waynode Cloud | Web + mobile workspace, chat, Git surface; terminal on self-host | pi engine; pi-codex-goal for autonomous runs; BYO keys self-hosted | | [OpenCode](https://opencode.ai/) | MIT | Local | Terminal (TUI), IDE, desktop | 75+ providers, incl. local models | | [Goose](https://github.com/aaif-goose/goose) | Apache-2.0 | Local | Desktop app, CLI, API | Model-agnostic incl. local; MCP extensions | | [Cline](https://cline.bot/) | Apache-2.0 | Local | VS Code extension, CLI, SDK | BYOK: Anthropic, OpenAI, Bedrock, Vertex, OpenRouter, others | | [Aider](https://aider.chat/) | Apache-2.0 | Local | Terminal | Any major model incl. local via Ollama | | [mini-SWE-agent](https://mini-swe-agent.com/latest/) | MIT | Local / CI | CLI | Any LM; >74% SWE-bench Verified | ## 1. OpenHands: the most direct open-source Devin OpenHands (formerly OpenDevin) began as an explicit open-source answer to Devin and has grown into what its repository now calls a "self-hosted developer control center for coding agents": a web UI from which you can run the OpenHands agent (or Claude Code, Codex, and Gemini agents) against your projects, with Docker-sandboxed execution ([github.com/OpenHands/OpenHands](https://github.com/OpenHands/OpenHands), ~80k stars as of mid-2026). The core is MIT-licensed and free to self-host with your own LLM key; a single `docker run` starts the web UI locally. Licensing gets more complicated beyond the core: the managed OpenHands Cloud has a free-to-start individual tier with at-cost model pricing, while the self-hosted *Cloud* distribution (a Helm chart for Kubernetes) ships under a Polyform Free Trial license limited to 30 days per year without a commercial agreement, and multi-user enterprise deployments are custom-priced ([openhands.dev/pricing](https://www.openhands.dev/pricing), [openhands.dev blog](https://www.openhands.dev/blog/openhands-cloud-self-hosted-secure-convenient-deployment-of-ai-software-development-agents)). If you want a free, fully open path, that is the MIT single-user version. **Pick it when:** you want issue-to-PR autonomy on your own infrastructure and are comfortable operating Docker and managing model keys. ## 2. Waynode: a self-hosted workspace, not a Devin clone [Waynode](https://github.com/fornace/waynode) takes a different position: it is not an autonomous software engineer you fire tasks at. It is an MIT-licensed, self-hosted coding-agent workspace. Each workspace is a real cloned Git repository on disk (a persistent worktree, not a disposable task container), and the agent (the open-source pi engine, with pi-codex-goal for autonomous goal runs) works inside it. Changed files, hunks, commits, branches, and push controls sit beside the conversation, so "done" means ready for review rather than merely finished running. Two properties distinguish it from everything else on this list. First, persistence: conversation, files, branches, and terminal state survive between visits, so a task started at a desk can be resumed later from another device. Second, mobile: the same workspace, session, and diff render on a phone, so you can follow a live run, review changed files, steer the agent, and push a reviewed change from wherever you are. Self-hosting starts by cloning the repo and running `./scripts/self-host.sh setup`; the guided installer asks for a GitHub or GitLab OAuth app and your model-provider key before it validates and starts Docker Compose. A managed option, Waynode Cloud, runs the same open-source stack from $39/mo (Starter: 3 seats, 3M agent tokens, 10 GB) with a 15-day free trial. **Pick it when:** you want a durable, reviewable place where agent work happens in your actual repo, especially if you want to check on and steer runs from a phone. Skip it if you specifically want fire-and-forget issue-to-PR autonomy with no review loop; OpenHands is closer to that. See [/learn](/learn) for how Waynode fits alongside cloud agents. ## 3. OpenCode: the terminal-native option [OpenCode](https://opencode.ai/) is an MIT-licensed coding agent built for the terminal. It is the most-starred repository in the category, with roughly 185k GitHub stars as of mid-2026 ([github.com/anomalyco/opencode](https://github.com/anomalyco/opencode)), and supports 75+ LLM providers, from Anthropic and OpenAI (including ChatGPT subscription accounts) to local models ([opencode.ai](https://opencode.ai/)). You launch it in a project directory, describe a task, and it searches, edits, and runs commands, pausing for review. It is interactive by design (closer to Claude Code than to Devin), but the provider breadth and MIT license make it a common self-hosted foundation. **Pick it when:** you live in the terminal and want maximum model flexibility with zero platform lock-in. ## 4. Goose: foundation-governed desktop and CLI agent [Goose](https://github.com/aaif-goose/goose) started at Block ([block.xyz announcement](https://block.xyz/inside/block-open-source-introduces-codename-goose)) and is now hosted under the Linux Foundation's Agentic AI Foundation; its repository lives in the `aaif-goose` organization. It is Apache-2.0, written in Rust, ships as a desktop app, CLI, and API, works with any LLM including local models, and extends through MCP integrations. It is a general-purpose agent rather than a pure software engineer, which cuts both ways: broad automation reach, less repo-workflow specialization. **Pick it when:** you want an open-governance agent that handles coding plus adjacent automation, on-device. ## 5. Cline: the VS Code route [Cline](https://cline.bot/) is an Apache-2.0 autonomous coding agent that lives primarily in VS Code, with a CLI and an open-source SDK exposing its agent harness ([github.com/cline/cline](https://github.com/cline/cline)). It is bring-your-own-key: you connect Anthropic, OpenAI, Bedrock, Vertex, or OpenRouter credentials and pay the provider directly, so the extension itself costs nothing. It inspects the project, edits files, runs commands, and drives a browser, asking permission at each step. **Pick it when:** your team works in VS Code and wants agentic edits with human-in-the-loop approval, no new infrastructure. ## 6. Aider: minimal, git-native pair programming [Aider](https://aider.chat/) is the veteran of this list: Apache-2.0, Python, terminal-based AI pair programming that builds a repo map, applies edits as diffs, and commits each change with a generated message. It works with Claude, GPT, DeepSeek, Gemini, or local models. It is deliberately not autonomous (you drive every step), and it remains in 0.x versioning (latest release v0.86.0), so expect occasional CLI flag changes ([github.com/Aider-AI/aider](https://github.com/aider-ai/aider)). **Pick it when:** you want tight, git-disciplined interactive editing rather than an agent that runs unattended. ## 7. mini-SWE-agent: the research baseline that ships Princeton and Stanford's [SWE-agent](https://swe-agent.com/) pioneered automated GitHub-issue solving; its successor, [mini-SWE-agent](https://github.com/SWE-agent/mini-swe-agent), compresses the agent to roughly 100 lines while scoring above 74% on SWE-bench Verified, MIT-licensed and used by Meta, NVIDIA, and IBM among others for evaluation pipelines ([mini-swe-agent.com](https://mini-swe-agent.com/latest/)). It is the leanest way to run "take this issue, fix it" autonomy in CI, but it ships no UI, no workspace, and no review surface. **Pick it when:** you want a scriptable, auditable autonomous loop for batch issue-fixing or benchmarking, and you will build the surrounding workflow yourself. ## How should you choose? - OpenHands if you want the closest thing to hosted Devin on your own infrastructure. - Waynode if you want a durable workspace with review-first Git and mobile access ([/guides/self-host-coding-agent-docker](/guides/self-host-coding-agent-docker)). - OpenCode or Cline (editor) or Aider (terminal, git-strict) as an interactive daily driver. - Goose if you want a general agent under open governance. - mini-SWE-agent for headless automation in CI. Every option here is free software; the real cost is model tokens plus your own operations time. Hosted Devin trades that operational load for quota-based consumption billing and a closed platform: a reasonable trade for some teams, and the one this whole category exists to make optional. ## FAQ ### What is the best open-source alternative to Devin in 2026? OpenHands is the most direct substitute: an MIT-core autonomous coding agent with a web UI, self-hosted via Docker, able to run multiple agent engines. Which tool is "best" depends on whether you need autonomy (OpenHands, mini-SWE-agent), a persistent workspace (Waynode), or interactive pairing (OpenCode, Cline, Aider). ### Is there a fully free, self-hosted Devin? Yes, in the sense that OpenHands (MIT core), Waynode (MIT), and mini-SWE-agent (MIT) are free to self-host without license fees. You still pay for LLM API tokens unless you run local models, and OpenHands' Kubernetes "Cloud self-hosted" distribution specifically uses a 30-day-per-year trial license rather than MIT. ### Is Waynode a Devin clone? No. Waynode is a self-hosted workspace where an agent (pi, with pi-codex-goal for autonomous goals) works inside a real cloned Git repository, with diffs, branches, and push beside the conversation, persistent across sessions and usable from a phone. It optimizes for review and continuity rather than fire-and-forget autonomy. ### How much does Devin cost compared to open-source options? As of the April 2026 restructure, Devin's plans are Free, Pro $20/mo, Max $200/mo, Teams $80/mo plus $40/mo per developer seat, and custom Enterprise; paid plans include auto-refreshing usage quotas with overages billed at API pricing ([devin.ai/pricing](https://devin.ai/pricing/)). Open-source tools have no license cost; you pay model providers directly, plus hosting if you run a server-based option like OpenHands or Waynode (Waynode Cloud starts at $39/month if you prefer managed hosting). ### Can these agents run with local models? Mostly yes. OpenCode, Goose, Cline, Aider, and OpenHands all support local models (typically via Ollama or an OpenAI-compatible endpoint), which removes token costs entirely at the price of lower model capability. Self-hosted Waynode is bring-your-own-key, so it uses whatever model endpoints you configure. --- --- title: Running coding agents from your phone description: How to follow, review, and steer AI coding agents from a phone, what a good mobile agent workflow requires, and where mobile honestly falls short. category: guides slug: coding-agents-on-your-phone date: 2026-07-12 updated: 2026-07-12 author: Francesco Frapporti keywords: coding agent mobile, run claude code from phone, review code on phone ai agent, mobile ai development workflow cover: /covers/coding-agents-on-your-phone.png --- ![Running coding agents from your phone Cover Image](/covers/coding-agents-on-your-phone.png) # Running coding agents from your phone You can run coding agents from a phone because the agent does not run *on* the phone: it runs in a cloud workspace or on a machine you own, and the phone is the surface where you start tasks, follow progress, review diffs, and approve or redirect the work. The major agent vendors ship some version of this today (Claude Code on the web monitored from the Claude mobile app, OpenAI Codex in the ChatGPT app, GitHub Copilot's cloud agent in GitHub Mobile, Cursor's cloud agents via an iOS app and mobile web), and self-hosted tools like Waynode do the same against your own infrastructure. **TL;DR** - Agents work asynchronously; a phone is enough to supervise them because supervision is reading and deciding, not typing code. - A usable mobile agent workflow needs four things: live task following, diff review, mid-task steering, and notification when the agent finishes or gets stuck. - Hosted options: Claude Code on the web (monitored from the Claude app), Codex in the ChatGPT mobile app, Copilot cloud agent in GitHub Mobile, Cursor cloud agents on iOS/web. - Self-hosted option: [Waynode](https://github.com/fornace/waynode) exposes the same workspace, session, and diff view on a phone, backed by a persistent Git worktree on your own server. - Honest limit: phones work for review and steering, poorly for deep debugging, multi-file editing, and anything requiring a real terminal for long stretches. ## Why does mobile matter for agent-driven development? Because the economics of coding agents are asynchronous. An agent given a well-scoped task works for minutes to hours without needing you; the human's job compresses into short, bursty interventions: read the plan, glance at the diff, answer a question, approve a push. None of those interventions requires a keyboard or a 27-inch monitor. They require the same things a messaging app requires: a readable thread, a notification, and a couple of buttons. This inverts the old assumption that mobile coding is a gimmick. Writing code on a phone remains impractical. But in an agent workflow you are rarely writing code; you are reviewing it, and review latency is what actually gates throughput. If an agent finishes a task at 6:40 pm and you don't see it until 9 am, the agent's speed bought you nothing. If you can approve or redirect from the train, the loop keeps moving. ## What does a good mobile agent workflow need? Four capabilities, in decreasing order of how often you use them: 1. Live task following: a stream of what the agent is doing right now (commands run, files touched, reasoning summaries) that survives you locking the phone and coming back. 2. Diff review: file-by-file, hunk-by-hunk changes rendered legibly on a small screen. A wall of unified diff in a chat bubble does not count; you need changed-file lists you can drill into. 3. Steering: the ability to send a correction mid-task ("use the existing retry helper, don't write a new one") and have it land in the same session, not spawn a fresh context-free run. 4. Push and hand-off: notification when the agent finishes or blocks, and a way to either finish the loop on the phone (approve, push, open a PR) or pick up the exact session later at a desk. Anything missing from this list turns the phone into a read-only status page, which is better than nothing but does not close the loop. ## Which hosted agents can you supervise from a phone? Verified against vendor documentation as of July 2026: | Tool | Mobile surface | Start tasks | Review diffs | Steer mid-task | Notes | |---|---|---|---|---|---| | Claude Code on the web | Claude mobile app / claude.ai | Yes | Yes | Yes | Research preview for Pro, Max, Team, and eligible Enterprise plans; sessions persist and can be moved to the CLI with `--teleport` ([docs](https://code.claude.com/docs/en/claude-code-on-the-web)) | | OpenAI Codex | ChatGPT app (iOS/Android) | Yes | Yes, incl. filtered diffs (staged, branch, last-turn) | Yes | Codex Remote (GA June 2026) pairs the phone to a Mac/Windows host via one-to-one QR pairing, to start or continue work, review progress, and approve actions ([changelog](https://developers.openai.com/codex/changelog)) | | GitHub Copilot cloud agent | GitHub Mobile | Yes | Yes, as branch diffs before a PR is opened | Yes, iterate on the branch, open the PR when ready | Can research the codebase and generate an implementation plan before writing code ([changelog](https://github.blog/changelog/2026-04-08-github-mobile-research-and-code-with-copilot-cloud-agent-anywhere/)); requires a paid Copilot plan ([docs](https://docs.github.com/en/copilot/concepts/agents/coding-agent/about-coding-agent)) | | Cursor cloud agents | iOS app; cursor.com/agents web/PWA | Yes | Yes | Yes | Agents run in isolated VMs, produce PRs with screenshots and logs; Android via PWA ([docs](https://cursor.com/docs/cloud-agents)) | | Waynode (self-hosted or cloud) | Mobile web, same workspace as desktop | Yes (chat or autonomous goal) | Yes: files, hunks, commits, branches beside the conversation | Yes, same persistent session | Open source (MIT); agent works in a real cloned Git repository that persists between visits | The hosted tools share a design: ephemeral or vendor-managed execution environments, with GitHub as the hand-off point (the agent's output is a branch or PR). That works well when your workflow already terminates in a PR. It works less well when you want the workspace itself (the checkout, the branch state, the terminal history) to persist and be revisitable from any device. ## How does Waynode handle the mobile workflow? Waynode's unit is a **space**: a real cloned Git repository on disk, persistent across sessions rather than recreated per task. The phone gets the same workspace as the desktop, not a companion view: - Chat with the agent (the engine is the open-source pi agent) or dispatch an autonomous goal via pi-codex-goal, and watch it work; the session survives closing the browser or switching devices. - Changed files, hunks, diffs, commits, and branches are rendered beside the conversation. In Waynode's model, "done" means ready for review, not merely finished running. - Steering messages land in the same persistent session, with the same worktree state, whether sent from a laptop or a phone. - A reviewed change can be pushed to GitHub or GitLab (connected via OAuth) directly from the mobile view. Because sessions persist, the desk-to-phone hand-off is simple: start a task at your desk, check the diff from your phone an hour later, resume in a terminal the next morning. Native macOS and iOS clients are planned (a native app exists in the repository). You can self-host it for free (clone the repo and run the guided `./scripts/self-host.sh setup`; Docker Compose v2, an OAuth app, and a model-provider key are required; see the [self-hosting guide](/guides/self-host-coding-agent-docker)) or use [Waynode Cloud](https://waynode.fornace.net), the managed version of the same stack, from $39/month with a 15-day free trial. For the broader self-hosted-versus-hosted decision, see [self-hosted vs cloud coding agents](/guides/self-hosted-vs-cloud-coding-agents); for a direct comparison with a hosted agent product, see [Waynode vs Cursor background agents](/compare/waynode-vs-cursor-background-agents). ## What can't you realistically do from a phone? Candidly, a fair amount: - Deep debugging. Stepping through a failure, reading long stack traces, and cross-referencing five files does not fit a 6-inch screen. Waynode exposes a full terminal in the workspace, and Codex Remote can drive a paired desktop host, but a terminal on a phone is an escape hatch, not a workflow. - Large-diff review. A 40-file refactor should not be approved from a phone. Mobile review works for the shape of a change and for small-to-medium diffs; big changes deserve a desk. - Writing significant code yourself. If the agent's output is wrong enough that you need to write the fix, that is a signal to defer, not to thumb-type a patch. - Initial task scoping for complex work. Well-scoped tasks come from context: reading the code, checking the issue history. Phones are for dispatching tasks you already understand. The honest framing: mobile turns agent downtime into progress by removing review latency. It does not replace the desk; it makes the time between desks productive. ## FAQ ### Can I run Claude Code from my phone? Not the CLI itself, but Claude Code on the web runs tasks on Anthropic-managed cloud infrastructure, and you can start and monitor those sessions from the Claude mobile app. It is in research preview for Pro, Max, Team, and eligible Enterprise plans, and sessions can be handed off to the terminal with `--teleport` ([documentation](https://code.claude.com/docs/en/claude-code-on-the-web)). ### Do coding agents actually run on the phone hardware? No. In every mainstream setup the agent executes in a cloud sandbox, a VM, or on a machine you own; the phone is a control surface for starting tasks, reviewing diffs, approving actions, and steering. This is why battery and phone compute are not limiting factors. ### Can I review and merge a pull request from my phone? Yes. GitHub Mobile lets you review the Copilot cloud agent's changes as a branch diff, iterate, and open the pull request when ready ([changelog](https://github.blog/changelog/2026-04-08-github-mobile-research-and-code-with-copilot-cloud-agent-anywhere/)), and Waynode lets you review changed files and hunks in the workspace and push a reviewed branch to GitHub or GitLab from the mobile view. Large or risky diffs are still better reviewed at a desk. ### What makes Waynode different from Codex or Copilot on mobile? Persistence and ownership. Hosted agents run in ephemeral vendor environments and hand results off as PRs; Waynode's agent works in a persistent cloned repository on infrastructure you control (or on Waynode Cloud), and the same session, files, and branches are reachable from any device. Self-hosted installations also expose the workspace terminal. It is open source under MIT. ### Do I need the Waynode Cloud plan to use it from a phone? No. The self-hosted version is free and MIT-licensed, and the mobile web experience is part of the open-source stack. Waynode Cloud ($39-$249/month, 15-day trial) adds managed server operation, updates, encrypted secrets, and Stripe billing on top of the same code. Interactive terminal access is currently self-hosted only. --- --- title: What is Waynode? The self-hosted coding-agent workspace explained description: Waynode is an open-source, self-hosted workspace where a coding agent works inside real cloned Git repos, with persistent sessions on any device. category: guides slug: what-is-waynode date: 2026-07-12 updated: 2026-07-12 author: Francesco Frapporti keywords: what is waynode, waynode ai, waynode review, coding agent workspace cover: /covers/what-is-waynode.png --- ![What is Waynode? The self-hosted coding-agent workspace explained Cover Image](/covers/what-is-waynode.png) # What is Waynode? The self-hosted coding-agent workspace explained Waynode is an open-source (MIT), self-hosted **coding-agent workspace**: a place where an AI coding agent works inside a real cloned Git repository, and where the conversation, files, branches, and terminal state persist between visits and across devices. You can run it yourself with Docker Compose for free, or use Waynode Cloud, a managed hosting of the same open-source stack. **TL;DR** - Each workspace ("space") is a **real cloned Git repository** on disk: a persistent worktree, not a disposable task container. - The agent engine is **pi** (open source), with **pi-codex-goal** for autonomous goal-driven runs. You can chat with the agent, send it an autonomous goal, or open a full terminal. - An **agent-native Git surface** (changed files, hunks, diffs, commits, branches, push) lives beside the conversation. "Done" means ready for review, not merely finished running. - Sessions persist and work on mobile: start at your desk, resume from a phone; the same workspace, session, and diff everywhere. - **Self-host free** (MIT, guided Docker Compose setup) or **Waynode Cloud** from $39/mo with a 15-day free trial. - Source: [github.com/fornace/waynode](https://github.com/fornace/waynode). ## What problem does Waynode solve? Coding agents and cloud dev environments each solve part of the loop, but the loop itself is fragmented. Cloud agents such as [Claude Code on the web](https://code.claude.com/docs/en/claude-code-on-the-web) run tasks on Anthropic-managed cloud infrastructure. That is effective for firing off parallel tasks, but the environment belongs to the provider and is scoped to the session, not a durable workspace you own. Cloud dev environments such as [GitHub Codespaces](https://docs.github.com/billing/managing-billing-for-github-codespaces/about-billing-for-github-codespaces) or [Ona](https://ona.com/pricing) (formerly Gitpod) give you a full machine, but the agent workflow is not the organizing principle, and on Ona's Core tier environments auto-delete after 7 days of inactivity. Waynode sits in the gap: a **durable, self-hostable place** where an agent works in your actual repository, the work survives between sessions, and you can return from any device, desktop browser or phone, to review, steer, and push. It is built specifically for the review-and-return loop around agent work. ## How does Waynode work? ### Spaces are real cloned repositories When you create a space, Waynode clones your repository (GitHub or GitLab, via OAuth) onto disk. The space is a persistent worktree: the files, branches, uncommitted changes, and terminal state remain exactly as the agent (or you) left them. There is no "re-hydrate the container" step and no chat attachment pretending to be a codebase. This is the core design decision everything else follows from. ### The pi agent engine The agent inside each space is **pi**, an open-source engine, with **pi-codex-goal** handling autonomous goal-driven runs. There are three ways to interact with it: 1. **Chat**: converse with the agent about the code, iteratively. 2. **Goal**: hand the agent an autonomous objective and let it run. 3. **Terminal**: open a full terminal in the workspace and do it yourself. Because all three operate on the same persistent worktree, you can mix them freely: start a goal, watch it in chat, drop to the terminal to fix something by hand, then resume. ### The Git surface: "done" means reviewable Waynode treats Git as a first-class part of the agent UI, not an export step. Changed files, hunks, diffs, commits, branches, and push live beside the conversation. When an agent run finishes, what you see is a reviewable change: you inspect the diff, adjust, commit, and push from the same screen. The standard Waynode framing: **"done" means ready for review, not merely finished running.** ### Mobile: the same workspace on a phone The same space, session, and diff render on a phone. In practice this means you can follow a live agent task from anywhere, review the changed files, steer the agent mid-run, and push a reviewed change without opening a laptop. macOS and iOS native clients are planned (a native app exists in the repository). ## Who is Waynode for? - Developers who want agent work to be durable. If you dislike that a cloud-agent task's environment evaporates when the task ends, spaces-as-real-repos is the fix. - Teams with self-hosting requirements. Repos, database, credentials, and LLM keys stay on your infrastructure. Hosted billing and Waynode usage limits are disabled on self-host. - People who review agent output on the go. The mobile session model is aimed at the "agent finished while I was away from my desk" moment. It is a weaker fit if you mainly want many short, parallel, fire-and-forget tasks with zero infrastructure; a managed cloud agent is simpler for that (see the comparison pages under [/learn](/learn) for specific matchups). ## Self-host vs Waynode Cloud | | Self-host | Waynode Cloud | |---|---|---| | Price | Free (MIT license) | Starter $39/mo · Pro $99/mo · Team $249/mo | | Setup | Clone → guided `./scripts/self-host.sh setup`; OAuth app and model key required | Sign up; 15-day free trial (5M trial tokens, 2 GB storage, 1 seat) | | Data | Repos, database, credentials, LLM keys, billing all stay with you | Managed server operation, updates, encrypted secrets, and Stripe billing; interactive terminal currently remains self-hosted | | Models | Bring your own model keys | Hosted fast/reasoning/max tiers (Fornace models, GLM, Qwen) | | Code | Same open-source stack | Same open-source stack | Hosted plan limits: Starter includes 3 seats, 3M agent tokens/mo, and 10 GB storage; Pro includes 10 seats, 8M tokens, 50 GB; Team includes 25 seats, 20M tokens, 200 GB. Billing is via Stripe web checkout. On the security side, the session secret and encryption key are operator-owned, and OAuth apps are configured per deployment. The default Compose deployment assumes a trusted individual or small team; KVM/microsandbox deployment is a separate advanced operator path. ## How does Waynode compare to other tools? These categories overlap but optimize for different things. Competitor figures below are from their public pages as of July 2026. | Tool | Category | Workspace model | Self-hostable | Entry price | |---|---|---|---|---| | **Waynode** | Coding-agent workspace | Persistent cloned repo (space), any device | Yes (MIT) | Free self-host; Cloud $39/mo | | [Claude Code on the web](https://code.claude.com/docs/en/claude-code-on-the-web) | Cloud coding agent | Session-scoped, Anthropic-managed cloud environment | No (agent CLI is local; cloud sessions are managed) | Included in Pro, Max, and Team plans (research preview) | | [Devin](https://devin.ai/pricing) | Autonomous AI engineer | Provider-managed cloud agents | No | Free tier; Pro $20/mo; Teams $80/mo + $40/mo per dev seat | | [GitHub Codespaces](https://docs.github.com/billing/managing-billing-for-github-codespaces/about-billing-for-github-codespaces) | Cloud dev environment | On-demand VM, usage-billed | No | $0.18/hr (2-core) + $0.07/GB-mo storage; free monthly quota on personal accounts | | [Ona](https://ona.com/pricing) (ex-Gitpod) | Agent + cloud dev environment | Managed environments; Core tier auto-deletes after 7 days idle | Enterprise VPC option | Core from $20/mo | | [Coder](https://coder.com/pricing) | Self-hosted dev environments | Template-provisioned workspaces on your infra | Yes (open source) | Free Community edition; Premium priced annually per user | Honest read: Devin and Claude Code are stronger for hands-off autonomous task volume on managed infrastructure. Codespaces, Ona, and Coder are stronger as general-purpose dev machines. Waynode's distinct offer is the combination: an agent-first workspace that is also a real, persistent repo you own, reachable from any device. Detailed matchups live under [/learn](/learn). ## How do I get started? Self-host: ```bash git clone https://github.com/fornace/waynode cd waynode ./scripts/self-host.sh setup ``` The installer requires Docker Compose v2, a GitHub or GitLab OAuth app, and a supported model-provider key. It generates the server secrets, validates the configuration, and starts on loopback by default. The [self-hosting guide](https://github.com/fornace/waynode/blob/main/docs/SELF-HOSTING.md) covers HTTPS, upgrades, backup, and restore. Then sign in through the OAuth app you configured and create your first space. For the managed route, Waynode Cloud offers a 15-day free trial for new organizations. See [/learn](/learn) for guides. ## FAQ ### Is Waynode free? Yes. Waynode is MIT-licensed and free to self-host; your repos, database, credentials, and LLM keys stay on your infrastructure. Waynode Cloud, the managed option, starts at $39/mo (Starter) after a 15-day free trial. ### What is a Waynode "space"? A space is a real cloned Git repository on disk: a persistent worktree where the agent works. Files, branches, conversation, and terminal state survive between visits, unlike disposable per-task containers. ### What AI agent does Waynode use? Waynode runs the open-source **pi** engine, with **pi-codex-goal** for autonomous goal-driven runs. You interact via chat, autonomous goals, or a full terminal in the workspace. Self-hosters bring their own model keys; Waynode Cloud includes hosted fast/reasoning/max model tiers (Fornace models, GLM, Qwen). ### Does Waynode work on mobile? Yes. The same workspace, session, and diff are usable from a phone: you can follow a live task, review changed files, steer the agent, and push a reviewed change. Native macOS and iOS clients are planned. ### Which Git providers does Waynode support? GitHub and GitLab, connected via OAuth configured per deployment. The Git surface (diffs, commits, branches, push) is built into the workspace next to the agent conversation. --- --- title: Why coding agents need persistent workspaces description: Ephemeral task runners discard branches, terminal state, and conversation context. Persistent real-repo workspaces make agent work reviewable and resumable. category: guides slug: persistent-workspaces-for-coding-agents date: 2026-07-12 updated: 2026-07-12 author: Francesco Frapporti keywords: persistent workspace coding agent, coding agent git worktree, stateful vs ephemeral ai agents cover: /covers/persistent-workspaces-for-coding-agents.png --- ![Why coding agents need persistent workspaces Cover Image](/covers/persistent-workspaces-for-coding-agents.png) # Why coding agents need persistent workspaces A persistent workspace is a coding-agent environment where the repository clone, working branches, terminal state, and conversation history survive between sessions, instead of being provisioned for one task and discarded afterward. Most cloud coding agents today run in the opposite model: an ephemeral container is created per task, the agent pushes a branch or opens a pull request, and everything else is thrown away. That model works for one-shot tasks but loses exactly the context you need when work spans more than one sitting: the uncommitted diff, the half-finished branch, the shell environment, and the reasoning that led there. **TL;DR** - Ephemeral agent runners (per-task containers or VMs) discard the working tree, terminal state, and most conversation context once a task ends; the surviving artifact is usually just a pushed branch or PR. - This makes multi-session work (iterating on review feedback, resuming after a day, steering mid-task from another device) awkward or impossible without re-provisioning and re-explaining. - The persistent-workspace pattern keeps a real Git clone on disk per project, with the agent, the diff view, and the terminal all attached to that same durable directory. - [Waynode](https://github.com/fornace/waynode) implements this pattern: each "space" is a real cloned repository, sessions survive between visits, and the Git surface (hunks, commits, branches, push) lives beside the conversation. - Ephemeral runners remain the better fit for high-volume parallel one-shot tasks; persistent workspaces are the better fit for work you review, steer, and resume. ## What do ephemeral agent runners actually lose? When a cloud agent runs each task in a fresh container, four kinds of state disappear at the end of the run: 1. The working tree. Uncommitted changes, stashes, generated files, and build artifacts exist only inside the container. If the agent stopped short of a pushed branch, that work is gone. 2. Branch and repo state. The agent's clone (its local branches, its view of history, any rebase-in-progress) is not the same clone next time. Every follow-up starts from a re-clone at some ref. 3. Terminal and process state. Running dev servers, watch processes, shell history, environment tweaks made during the session: none of it carries over. 4. Conversation and task context. Follow-ups either happen inside a time-limited window or start a new task where the agent must rediscover what was done and why. Concretely, in the current generation of tools (all verified against vendor docs, July 2026): - OpenAI Codex cloud runs each task in a container that checks out your repo at the selected branch or commit and runs your setup script; container state is cached "for up to 12 hours" to speed up follow-ups, after which a new container starts from scratch ([Codex cloud environment docs](https://learn.chatgpt.com/docs/environments/cloud-environment)). - Cursor cloud agents run in isolated VMs that "clone your repo … and work on a separate branch, then push changes to your repo for handoff"; each agent starts from an environment configured for the repo (a saved snapshot or a Dockerfile) ([Cursor cloud agent docs](https://cursor.com/docs/cloud-agent)). - Claude Code on the web runs every task in an isolated sandbox with network and filesystem restrictions, with Git interactions handled through a secure proxy to authorized repositories; the deliverable is the change delivered back through Git, not a durable environment you return to ([Claude Code on the web announcement](https://claude.com/blog/claude-code-on-the-web)). None of this is a design flaw. Ephemerality is a deliberate trade: it buys strong isolation, easy parallelism, and zero cleanup. The cost is that the pushed branch becomes the *only* durable artifact, and everything upstream of it, the process, evaporates. ## Stateful vs ephemeral AI agents: when does state matter? State matters whenever the unit of work is longer than one autonomous run. Three common situations: Review-and-iterate loops. An agent produces a diff; you read it on your phone that evening and want two functions renamed and a test added. In an ephemeral model, that feedback spawns a new task in a new container that re-clones and re-orients. In a persistent workspace, the same session with the same working tree is still there: the agent applies the feedback to the branch it already has checked out. Interrupted work. Real tasks get interrupted by meetings, CI failures, or better ideas. A persistent workspace tolerates this by default: the branch, the diff, and the conversation are exactly where you left them, whether you return in an hour or a week. Even general-purpose cloud dev environments acknowledge this need. GitHub Codespaces stops a codespace after an idle timeout (default 30 minutes) but *retains* the stopped codespace, by default for 30 days, precisely so work in progress is not lost ([Codespaces lifecycle docs](https://docs.github.com/en/codespaces/about-codespaces/understanding-the-codespace-lifecycle)). Human-steered autonomy. If you want to watch a long-running goal, inspect intermediate diffs, and redirect the agent mid-flight, there has to be a stable *place* to attach to. Ephemeral runners expose a task log; a persistent workspace exposes the actual repository state at every moment. Conversely, state is dead weight for genuinely one-shot work: "fix this lint error across 40 repos" is better served by 40 disposable containers than by 40 long-lived workspaces. Stateful and ephemeral are complements, not competitors. ## What does the persistent-workspace architecture look like? The pattern has three load-bearing pieces. Waynode is used as the concrete example here because it implements all three in the open ([source on GitHub](https://github.com/fornace/waynode)); the pattern itself is general. ### 1. A real clone on disk, not a task container Each workspace ("space" in Waynode) is a real cloned Git repository: a persistent worktree that exists independently of any agent run. The agent operates *inside* the clone rather than the clone existing *inside* the agent's sandbox. This inverts the ephemeral model's ownership: the repository directory is the durable object, and agent sessions, terminals, and autonomous runs all attach to it. Because it is a normal clone, everything Git can express (branches, worktrees, stashes, reflog) is available and survives across sessions. ### 2. An agent-native Git surface If the workspace persists, the interface must show its Git state continuously, rather than only at hand-off time. In Waynode, changed files, hunks, diffs, commits, branches, and push live beside the conversation. The practical effect is a different definition of "done": an agent task is finished when the change is *ready for review*: inspectable as a diff, on a branch, one action from pushed. Ephemeral runners approximate this with an auto-opened PR; a persistent workspace lets you review and adjust *before* anything leaves the workspace. ### 3. Sessions that survive, on every device The third piece is durable sessions: conversation, files, branches, and terminal state persist between visits, and the same workspace is reachable from any device. Waynode is mobile-first: the same workspace, session, and diff are available on a phone: follow a live task, review changed files, steer the agent, push a reviewed change. This only works because there is one canonical stateful workspace to point every client at; an ephemeral-per-task model has no equivalent object to reconnect to once the task ends. Around these three pieces, the remaining architecture is conventional: Waynode is MIT-licensed and self-hostable through a guided Docker Compose installer, connects to GitHub and GitLab via OAuth, and runs the open-source pi agent engine (with pi-codex-goal for autonomous goal runs). The default Compose deployment is for a trusted individual or small team; a separate KVM/microsandbox deployment is an advanced operator path. A managed option ([Waynode Cloud](/learn)) runs the same stack with a 15-day free trial; self-hosters bring their own model keys. ## How do persistent workspaces compare to the alternatives? | Property | Ephemeral task runner (Codex cloud, Cursor cloud agents, Claude Code web) | Cloud dev environment (Codespaces) | Persistent agent workspace (Waynode) | |---|---|---|---| | Unit of provisioning | Per task / per session | Per developer environment | Per repository ("space") | | Working tree after task ends | Discarded (Codex caches ≤ 12 h) | Retained while codespace exists (default retention 30 days) | Persists between sessions | | Terminal / process state | Lost at task end | Suspended on idle timeout (default 30 min), restored on restart | Persists between visits | | Conversation context | Task-scoped | N/A (editor, not agent-first) | Persists with the workspace | | Primary artifact | Pushed branch / PR | The environment itself | Reviewable diff + branch, pushed when ready | | Parallel one-shot tasks | Strong fit | Poor fit | Possible, but not the design center | | Self-hostable | No | No | Yes (MIT) | Sources: [Codex cloud environments](https://learn.chatgpt.com/docs/environments/cloud-environment), [Cursor cloud agent docs](https://cursor.com/docs/cloud-agent), [Claude Code on the web](https://claude.com/blog/claude-code-on-the-web), [Codespaces lifecycle](https://docs.github.com/en/codespaces/about-codespaces/understanding-the-codespace-lifecycle). Each column is good at its own job. Ephemeral runners win on isolation and fan-out. Codespaces wins as a full human dev environment with deep editor integration. The persistent agent workspace wins when the goal is agent work that a human reviews, steers, and resumes, because it is the only model in which the *process* itself is durable, in addition to the output. ## Does persistence weaken isolation? No. It changes where isolation is applied. Ephemeral runners get isolation for free by discarding the environment. A persistent workspace has to isolate execution while keeping data durable. Waynode has a separate KVM/microsandbox operator path for that separation; its default Compose deployment instead assumes a trusted individual or small team and does not provide hardware isolation between users. The operator owns the session secret and encryption key on self-hosted deployments. On hosted plans, workspaces are isolated and secrets are encrypted. The durable clone and disposable execution environment are separate layers, which is the same separation Git encourages between the object store and working tree. ## FAQ ### What is a persistent workspace for a coding agent? A persistent workspace is a durable, per-repository environment (a real Git clone on disk) where the agent's working tree, branches, terminal state, and conversation history survive between sessions. It contrasts with ephemeral runners that provision a fresh container per task and discard it afterward. ### Are tools like Codex cloud and Cursor cloud agents ephemeral? Largely, yes. Codex cloud runs each task in a container and caches container state for up to 12 hours before starting fresh ([docs](https://learn.chatgpt.com/docs/environments/cloud-environment)); Cursor cloud agents run in isolated VMs that clone the repo, work on a branch, and push for handoff ([docs](https://cursor.com/docs/cloud-agent)). The durable artifact in both cases is the pushed branch or PR, not the environment. ### When is an ephemeral agent runner the better choice? For high-volume, parallel, one-shot tasks: mass refactors across many repos, batch dependency bumps, triaging a queue of small fixes. Provisioning dozens of disposable containers is cheaper and safer than maintaining dozens of long-lived workspaces for work nobody will resume. ### How is a persistent agent workspace different from GitHub Codespaces? Codespaces is a cloud development environment built around a human using an editor; it retains stopped environments (default retention 30 days) but is not agent-first. A persistent agent workspace like Waynode is built around the agent loop: the conversation, the diff surface, and autonomous goal runs are the primary interface, attached to a real repository clone you can also open a terminal in. ### Can I self-host a persistent agent workspace? Yes. Waynode is MIT-licensed: clone the repository and run `./scripts/self-host.sh setup`. The guided installer requires Docker Compose v2, an OAuth app, and a model-provider key; it generates the server secrets and starts on loopback by default, with your repos, database, credentials, and LLM keys staying on your infrastructure. See the [self-hosting guide](https://github.com/fornace/waynode/blob/main/docs/SELF-HOSTING.md) for setup and operations.