What Is DevSpace Ultra and Why Multi-Agent Workspaces Matter

DevSpace Ultra is an MIT-licensed distribution of DevSpace that adds a production-oriented multi-agent runtime layer. The upstream DevSpace project, created June 14, 2026, is a small self-hosted MCP server that lets ChatGPT open a real project folder, read and edit files, run shell commands, and show diffs — the same loop as Codex or Claude Code, but running on your laptop against the folder you actually have open. DevSpace Ultra keeps all of that local MCP workspace functionality (files, code search, editing, terminal, artifacts, skills, self-hosting) and adds a Chat Swarm control plane for running multiple independent ChatGPT Classic worker conversations on one computer.

Why does this matter? Plain ChatGPT chat has no filesystem access, and Code Interpreter only runs Python in a throwaway container. Codex works against a cloned repo in a cloud sandbox, not the folder open in your editor. A multi-agent dev workspace closes that gap: it gives you a real, local, parallel workforce of coding agents instead of a single sequential chat. The category is being legitimized by OpenAI itself, which introduced native workspace agents in ChatGPT — but DevSpace Ultra represents the self-hosted, community-driven alternative that keeps your code local and your data on your own hardware.

DevSpace Ultra vs OpenAI Workspace Agents: Self-Hosted vs Native

The “multi-agent dev workspace” keyword now spans two very different approaches. OpenAI’s native workspace agents are the mainstream, enterprise direction: they live inside ChatGPT, are managed by OpenAI, and require no self-hosting. DevSpace Ultra is the opposite: a self-hosted, open-source tool that orchestrates ChatGPT Classic workers you control.

The trade-off is control versus convenience. Native workspace agents are easier and require no infrastructure, but they run in OpenAI’s cloud. DevSpace Ultra keeps everything local and gives you fine-grained control over how many workers run, how they scale, and how they recover — at the cost of setup and maintenance. For developers who care about data locality, cost control, or running many parallel workers on one subscription, the self-hosted route is compelling.

How the Chat Swarm Control Plane Works (Elastic Worker Pool)

The heart of DevSpace Ultra is the Chat Swarm backend, a control plane that manages a pool of independent ChatGPT Classic worker conversations. The key design decision is that it separates runtime capacity from task routing. You configure a desired number of workers, and the elastic scaling mechanism grows or shrinks the runtime and Swarm capacity to match.

The elastic worker pool works like this:

• Main agent scales workers up and down based on workload, so you are not stuck with a fixed pool.
• Live Swarm resize can happen without losing completed work — scaling down only removes safe idle tail capacity and never interrupts a busy worker.
• Independent runtimes on Windows use isolated package identities, profiles, sessions, and conversations, so each worker is a clean, separate ChatGPT Classic instance.
• Same-worker context continuity lets you reopen a worker at the exact saved ChatGPT conversation and continue with the held worker token.
• Zero-copy bootstrap launches a worker, minimizes it, sends it into a sub-agents ChatGPT Project, joins the Swarm, and parks it — without manual invite-code copy/paste.
• Backend-first routing means normal work is dispatched through the Chat Swarm backend; UI/CDP automation is reserved for lifecycle, bootstrap, and recovery only.

The backend supports create/join/status, dispatch/collect/cancel, long parked worker waits with submit/repark, targeted or first-available routing, idempotent taskKey retries, persistence across restart, worker recycle fallback, and safe live capacity resize. This is a genuinely production-oriented design rather than a script that spawns a few chat windows.

Setting Up DevSpace Ultra: One-Click Install and Requirements

Installation is designed to be one command. On Windows, run the PowerShell installer; on macOS and Linux, use the shell installer; and there is also an npm global install:

# Windows (PowerShell)
irm https://.../install.ps1 | iex

# macOS / Linux
curl -fsSL https://.../install.sh | bash

# Any platform via npm
npm install -g github:enwong93-sketch/devspace-ultra#main

Before you install, check the requirements:

• Node.js >= 22.19 and < 27 (Node 22 LTS recommended)
• Windows 10/11 x64 for automatic isolated desktop runtime cloning
• ChatGPT Classic Windows Desktop app signed in
• 16 GB RAM for 2-4 workers; 32 GB+ for larger pools
• No GPU required

The base MCP workspace, Chat Swarm backend, manual/browser workers, and elastic resize work on Windows, macOS, and Linux. But the automatic isolated desktop runtime cloning, recovery, and canary/rolling update manager are Windows-only. If you are on macOS or Linux, you get the full control plane but not the Windows package-identity worker-cloning path.

Configuring ChatGPT Classic Workers and the sub-agents Project

Once installed, you configure how many workers you want and how they are organized. The reservedWorkers setting lets you reserve runtime capacity, and by default no runtime is reserved — you scale up on demand.

A useful organizational feature is the sub-agents Project routing: new worker conversations are created inside a configured ChatGPT Project instead of cluttering your general chat list. This keeps your worker pool tidy and separate from your personal conversations.

The runtime tools you will use include:

• chat_swarm_runtime_status / ensure / scale / recover / autojoin / setup / stop
• chat_swarm_elastic_scale
• chat_swarm_update_status / rollout

These give you direct control over the worker pool: check status, ensure runtimes are present, scale capacity, recover interrupted workers, autojoin the Swarm, and manage updates.

The Production Flow: Assess, Scale, Dispatch, Collect, Shrink

DevSpace Ultra is designed around a repeatable production workflow rather than ad-hoc experimentation. The recommended flow is:

1. Assess the workload — how many parallel tasks do you actually need?
2. Choose desiredWorkers — set the target pool size.
3. Elastic scale the runtime and Swarm capacity to match.
4. Dispatch tasks to the worker pool.
5. Collect and synthesize the results.
6. Shrink the idle tail workers to free resources.

This assess → scale → dispatch → collect → shrink loop is what makes the tool feel like a real orchestration system rather than a batch script. Because scaling down only removes safe idle capacity, you can shrink the pool aggressively after a burst without risking in-flight work. The elastic scaling design is the key differentiator: one ChatGPT subscription can power a parallel worker pool that grows and shrinks with your workload.

Recovery, Updates, and Resilience (Canary-First Rolling Updates)

A multi-agent system is only useful if it survives failures, and DevSpace Ultra invests heavily in resilience. The recovery system detects missing runtimes, interrupted connections, stale worker loops, and blocking UI notices, then reopens the exact worker conversation to continue where it left off.

The update compatibility manager is especially notable. It supports:

• Canary runtime — test a new version on one worker first
• Profile backup — snapshot before any change
• Rolling worker update — update workers incrementally
• Exact-conversation restore — bring workers back to their precise state
• Verification and rollback — confirm the update worked or revert

This canary-first approach means you can update your worker pool without losing completed work or breaking running conversations. For a tool that orchestrates live AI workers, this level of update hygiene is a real differentiator and a strong argument for the project’s production readiness.

Browser Control and the Unified Capability Runtime (v0.2/v0.3)

DevSpace Ultra has evolved quickly. Version 0.2.0 added local-first DevSpace Browser Control, a Chrome extension that gives workers exclusive per-tab claims. Each tab shows an “AGENT CLAIMED THIS TAB” strip, and the system provides semantic accessibility snapshots, screenshots, and console/network diagnostics. This lets workers interact with web pages in a controlled, credential-safe way.

Version 0.3 added the Unified Agent Capability Runtime, a capability_* surface for discovering, installing, inspecting, enabling, updating, isolating, and calling reusable capabilities. It understands Agent Skills, instruction packs, MCP tools/prompts/resources, DevSpace manifests, Claude/Codex plugin metadata, and MCP Registry metadata. In the v0.3 release, DevSpace Ultra scanned 71 Codex plugin manifests and found 71/71 structural compatibility — a strong signal that the capability layer is broadly interoperable with the existing plugin ecosystem.

Security Model: Self-Hosted MCP, Tokens, and Credential Boundaries

Because DevSpace Ultra is self-hosted, security is your responsibility — and the project takes it seriously. The MCP model is self-hosted, and the guidance is to keep the server bound or exposed only through a controlled transport and to use authentication. Worker and orchestrator tokens are not written to normal controller logs, reducing the risk of credential leakage.

Browser Control uses one-time pairing and exclusive per-tab claims, and it persists only hashes of tokens rather than the tokens themselves. This credential-boundary design means a compromised worker cannot trivially exfiltrate your other credentials. As with any self-hosted tool, you should review the security model, keep the server behind controlled transport, and use auth before exposing it beyond localhost.

Platform Support and the Windows-Only Reality Check

It is important to be honest about the platform story. The base MCP workspace, Chat Swarm backend, manual/browser workers, and elastic resize work on Windows, macOS, and Linux. But the headline features — automatic isolated desktop runtime cloning, recovery, and the canary/rolling update manager — are Windows 10/11 x64 only.

This is the key differentiator and the key limitation. If you are on Windows, you get the full package-identity worker-cloning path that makes the elastic pool seamless. If you are on macOS or Linux, you can still run the control plane and manage workers, but you lose the automatic runtime cloning and recovery that make the Windows experience so smooth. Before adopting DevSpace Ultra, confirm which features you actually need and whether your platform supports them.

The “Free” Question: ChatGPT Plan Requirements

DevSpace Ultra itself is free and open-source (MIT), but the “free” label needs a reality check. The tool orchestrates ChatGPT Classic workers, which means you need a ChatGPT subscription. More importantly, custom ChatGPT Plugins (formerly connectors) live behind Developer Mode, which requires a paid plan — Plus, Pro, Business, Enterprise, or Edu — and is not available on the Free plan.

So the honest cost picture is:

• DevSpace Ultra: free (MIT, open source)
• ChatGPT subscription: required (paid plan for Developer Mode / Plugins)
• Hardware: 16 GB RAM for 2-4 workers, 32 GB+ for larger pools, no GPU

The value proposition is that one paid ChatGPT subscription can power many parallel workers, which is far cheaper than paying per-agent for a managed multi-agent platform. But it is not free in the absolute sense — you need a paid ChatGPT plan and a reasonably specced machine.

Common Pitfalls and Rough Edges

DevSpace Ultra is genuinely new — the upstream project’s first commit was June 14, 2026, and DevSpace Ultra itself was created August 18, 2026. As of the research date it had 35 GitHub stars and 5 forks, compared to 4,032 stars for the upstream Waishnav/devspace project. That maturity gap means you should expect rough edges:

• Young project: 35 stars and 5 forks means a small community and limited battle-testing.
• Windows-only features: the best features (runtime cloning, recovery, canary updates) do not work on macOS/Linux.
• Paid plan required: Developer Mode and Plugins need a paid ChatGPT plan, not Free.
• Node version constraints: you must be on Node >= 22.19 and < 27, which may conflict with other tooling.
• Self-hosting burden: you own the security, transport, and auth setup.

None of these are deal-breakers, but they are the reality of adopting a young, self-hosted tool. If you are comfortable with early-stage software and want local control, the trade-offs are acceptable.

Conclusion: Is DevSpace Ultra Right for Your Multi-Agent Workflow?

DevSpace Ultra is a compelling answer to the question of how to build a multi-agent dev workspace without paying per-agent for a managed platform. It turns one ChatGPT subscription into an elastic pool of parallel coding workers on your own machine, with a production-grade control plane, recovery, and canary-first updates. The self-hosted MCP model keeps your code local, and the elastic scaling design is genuinely thoughtful.

It is not for everyone. The best features are Windows-only, you need a paid ChatGPT plan, and the project is very young. But if you are on Windows, want local control over your AI workforce, and are comfortable with early-stage open-source software, DevSpace Ultra is worth a serious look. For everyone else, it is a clear sign of where the multi-agent dev workspace category is heading — and a strong open-source alternative to OpenAI’s native workspace agents.

FAQ

What is DevSpace Ultra? DevSpace Ultra is an MIT-licensed, open-source distribution of DevSpace that adds an elastic Chat Swarm control plane for running multiple independent ChatGPT Classic worker conversations on one computer, turning one ChatGPT subscription into a parallel pool of coding agents.

Is DevSpace Ultra free? The software itself is free and open-source (MIT), but you need a paid ChatGPT plan because custom Plugins and Developer Mode are required and are not available on the Free plan. You also need a machine with at least 16 GB RAM for a small worker pool.

What are the system requirements for DevSpace Ultra? You need Node.js >= 22.19 and < 27 (Node 22 LTS recommended), 16 GB RAM for 2-4 workers (32 GB+ for larger pools), no GPU, and a signed-in ChatGPT Classic Windows Desktop app for the automatic runtime cloning features.

Does DevSpace Ultra work on macOS and Linux? Partially. The base MCP workspace, Chat Swarm backend, manual/browser workers, and elastic resize work on all three platforms, but the automatic isolated desktop runtime cloning, recovery, and canary/rolling update manager are Windows 10/11 x64 only.

How is DevSpace Ultra different from OpenAI’s native workspace agents? DevSpace Ultra is self-hosted and keeps your code and data local, with user-controlled elastic worker scaling. OpenAI’s native workspace agents are managed in the cloud and easier to use but give you less control and keep your work in OpenAI’s infrastructure.

What Is Proliferate? The Open-Source, Self-Hostable Codex

Proliferate is an open-source AI IDE that positions itself as a self-hostable Codex for any coding agent. Rather than locking you into one model provider or one agent harness, it treats the agent as a pluggable component. The project is licensed under AGPL-3.0 and, as of August 2026, sits at roughly 404 GitHub stars and 66 forks, created on 2026-04-30 by a Y Combinator S25 founder named Pablo (GitHub API).

The core idea is simple but powerful: instead of choosing between Claude Code, Codex, OpenCode, Cursor, or Grok, you run them all side by side in a single workspace. Each task gets its own isolated git worktree, terminal, conversation, and review state, so parallel agents never step on each other’s changes. This is a fundamentally different model from a single-agent IDE like Cursor or a terminal-first tool like OpenCode.

Proliferate’s Show HN post reached 45 points on Hacker News on 2026-08-21 (HN Algolia), which is where much of the early community discussion and feedback originated.

Why “Codex for Any Coding Agent” Matters — The Everything-App Thesis

OpenAI has been explicit about its ambition: Codex should become the main interface for getting work done, not just a code autocompleter. The “everything app” thesis holds that the coding agent will eventually be where you manage tasks, run workflows, and delegate work across your entire development lifecycle.

Proliferate is the open-source, self-hostable version of that thesis — but with a crucial twist. Where OpenAI’s Codex is tied to OpenAI’s models and cloud, Proliferate preserves optionality across labs and model providers. You can run the same orchestration layer with Claude, Codex, open-weight models, or self-hosted inference. That optionality is the entire point: you get the “everything app” workflow without surrendering control of your data or your model choices.

For teams that are wary of depending on any single vendor, this is the difference between renting an interface and owning one. The everything-app thesis becomes viable for organizations that would never send proprietary code to a third-party cloud.

Key Features: Parallel Agents, Worktree Workspaces, and Subagents

Three features define Proliferate’s approach to multi-agent orchestration.

Parallel agents in one workspace. Proliferate runs Claude Code, Codex, OpenCode, Cursor, and Grok simultaneously. Each agent uses a native harness, which preserves each agent’s native inference and configuration options — including Bedrock, Azure, and self-hosted inference. You are not getting a watered-down reimplementation; you are getting the real agent with its real settings.

Isolated git worktrees. Every task gets its own git worktree for its branch, plus a dedicated terminal, conversation, and review state. This is what makes parallel execution safe. Without isolation, two agents editing the same branch would collide; with worktrees, each agent works in a clean sandbox that can be reviewed and merged independently.

Inter-agent communication via subagents. A parent agent can spawn and communicate with another supported agent as a subagent. For example, a Fable session could delegate a coding task to Codex, then have OpenCode review the resulting pull request. This cross-harness delegation is the real differentiator — it is not just a single-agent IDE, but an orchestration layer where agents of different types cooperate on one task.

The Workflows Feature: Automating Recurring Agent Runs

Proliferate’s Workflows feature is arguably its automation moat. A workflow is a reusable chain of agent sessions with human approval gates, where the harness and model are chosen per step.

This matters because most coding-agent tools are one-shot: you start a session, it does a task, and you start over. Workflows let you encode a repeatable process — say, “run Codex to implement a feature, then have OpenCode review the diff, then pause for human approval before merging.” Each step can use a different harness and model, and the human approval gate sits exactly where you want it.

For teams that run the same kinds of tasks over and over — dependency bumps, code reviews, release prep — Workflows turn a manual multi-agent dance into a one-command automation. This is the feature that moves Proliferate from “a nice IDE” to “a platform for agent-driven development.”

Self-Hosting Options: Docker, AWS, Kubernetes, and Air-Gapped

The full control plane of Proliferate is self-hostable, which is the core of the “self-hostable Codex” promise. The options are:

• Docker Compose with Caddy, Postgres, and the API — the fastest path to a self-hosted instance
• AWS one-click CloudFormation on EC2
• GCP and Azure deployments
• Kubernetes for teams already running container orchestration
• Air-gapped operation for environments with strict data-control requirements

The air-gapped option is significant. For regulated industries, defense, or any organization that cannot send code to a public cloud, the ability to run the entire control plane offline — combined with self-hosted inference — means you can get a full multi-agent coding platform with zero external data egress.

This is the strongest argument for Proliferate over a hosted Codex: data control. You decide where the control plane runs, where the models run, and what leaves your network.

Proliferate vs. the Competition (Paseo, t3code, OpenHands, OpenCode)

Proliferate does not exist in a vacuum. The open-source coding-agent space is crowded, and each competitor occupies a different position on the spectrum from “lightweight IDE” to “heavyweight platform.”

The star counts tell a story about maturity and mindshare. OpenHands dominates with roughly 85k stars as the leading open-source autonomous coding platform, but it is heavier and more platform-centric than a self-hostable IDE. t3code (~20k stars, MIT) is frequently compared to Proliferate in HN discussion as a lighter-weight, single-agent option. OpenCode (~13.7k stars, Go, MIT) is terminal-first and single-agent.

Paseo (~15k stars) is the closest direct competitor on multi-agent orchestration, and it is where Proliferate faces its sharpest comparison. HN commenters repeatedly praised Paseo’s clear documentation and quick setup, and Paseo won on cross-device control (PC to Mac/iPhone). Proliferate’s edge is its native harnesses and self-hosting depth, but it trails badly on ease of adoption.

The Setup-Friction Problem: What HN Reviewers Actually Said

The most honest signal in the research is the setup-friction tradeoff. Proliferate’s Show HN thread drew a consistent theme: the docs are confusing and setup is frustrating, while Paseo was praised for being easy to set up.

This is a real adoption barrier, and it matters more than star count. A self-hostable Codex is only useful if teams can actually get it running. When the value proposition is “run five agents in parallel with isolated worktrees,” a confusing onboarding experience undermines the pitch — users who cannot get past setup never discover the orchestration features that make the tool worth using.

HN commenters also questioned the need for another layer on top of OpenCode, noting that OpenCode already covers essentially every model and provider. That is a fair challenge: if a single terminal agent already reaches every model, what does an orchestration layer add? The answer Proliferate gives is parallelism and cross-harness delegation — but it has to make that case clearly, and the current docs are not doing it well enough.

Who Should Use Proliferate — and Who Shouldn’t

Proliferate is not for everyone, and being honest about that is useful.

Use it if: you want to run multiple coding agents in parallel without collisions; you need cross-harness delegation (one agent spawning another); you require self-hosting or air-gapped operation for data control; or you want to preserve model optionality across labs rather than committing to one vendor.

Skip it if: you want a quick, single-agent setup; you are happy with a terminal-first tool like OpenCode; you need cross-device control from desktop to mobile (Paseo does this better); or you are not willing to invest in the setup friction and documentation gaps that early users reported.

The honest read is that Proliferate is early-stage — ~404 stars and a confusing onboarding — but it occupies a genuinely distinct niche: the self-hostable, multi-agent, cross-harness orchestration layer. If that niche is your requirement, there is no mature alternative that does all of it.

Verdict: Is Proliferate the Self-Hostable Codex You’ve Been Waiting For?

Proliferate is the most credible open-source answer to the “self-hostable Codex” question, but it is a bet on potential rather than polish. The architecture is right: native harnesses, isolated worktrees, cross-harness subagents, reusable workflows, and a fully self-hostable control plane including air-gapped operation. That is a compelling combination that no single competitor matches end to end.

The weaknesses are equally clear: early-stage star count, confusing documentation, and a setup experience that HN reviewers found frustrating compared to Paseo. For a tool whose whole pitch is “run everything in parallel,” the onboarding friction is the biggest risk to adoption.

If you need a self-hostable, multi-agent Codex alternative with data control and model optionality, Proliferate is worth evaluating — with the expectation that you will spend time on setup. If you need something that just works today with minimal friction, Paseo or a single-agent tool like t3code or OpenCode is the safer choice. Proliferate is the one to watch, and the one to try if you are willing to invest in the setup.

FAQ

What is a self-hostable Codex? A self-hostable Codex is an open-source coding-agent platform you run on your own infrastructure rather than depending on a single vendor’s cloud. Proliferate is one such platform, letting you run multiple coding agents in parallel with full control over your data and model choices.

Which coding agents does Proliferate support? Proliferate supports Claude Code, Codex, OpenCode, Cursor, and Grok through native harnesses. Native harnesses preserve each agent’s native inference and configuration options, including Bedrock, Azure, and self-hosted inference.

Is Proliferate free and open source? Yes. Proliferate is licensed under AGPL-3.0 and is open source. As of August 2026 it had roughly 404 GitHub stars and 66 forks.

Can I run Proliferate without sending my code to a cloud? Yes. The full control plane is self-hostable via Docker Compose, AWS CloudFormation, GCP, Azure, and Kubernetes, and it supports air-gapped operation. Combined with self-hosted inference, this allows zero external data egress.

How does Proliferate compare to Paseo? Proliferate and Paseo both do multi-agent orchestration, but Paseo has more stars (~15k), clearer documentation, and better cross-device control, while Proliferate offers deeper self-hosting options and native harnesses. HN reviewers found Paseo easier to set up.