# AI use cases for Wemux (wemux-ai/wemux)

Repo: [wemux-ai/wemux](https://github.com/wemux-ai/wemux) | Use cases: 5 | Page: https://dedupedai.com/use-cases/wemux-ai-wemux/

Wemux is a self-hostable, Apache-2.0 platform that orchestrates AI agents to run coding work in isolated Git worktrees on worker machines you control.

This file holds every use case of this repo. Each one starts with a "## " heading and ends with its URL.

- Run a local agent control plane and worker: https://dedupedai.com/use-cases/wemux-ai-wemux/run-local-agent-control-plane/
- Add a worker on a second Mac or Linux machine: https://dedupedai.com/use-cases/wemux-ai-wemux/add-worker-on-another-machine/
- Deploy your own Wemux instance on Railway: https://dedupedai.com/use-cases/wemux-ai-wemux/deploy-own-instance-on-railway/
- Delegate coding tasks to agents on your own workers: https://dedupedai.com/use-cases/wemux-ai-wemux/delegate-coding-tasks-to-workers/
- Create agent tasks from Feishu, Slack or DingTalk: https://dedupedai.com/use-cases/wemux-ai-wemux/create-tasks-from-team-chat/

## How to run a local agent control plane and worker with Wemux

Repo: [wemux-ai/wemux](https://github.com/wemux-ai/wemux) | Difficulty: Intermediate | Time: 30 minutes | Basis: From the README

Start Postgres, the control plane, the console and a worker on one machine to test agent task runs.

**Who it is for:** A developer evaluating Wemux who wants a full local setup before using it on real repos.

**The problem:** Agent orchestration tools are hard to judge without seeing a task move from planning to a worker and back.

**The outcome:** A running console and API with one paired worker that can accept a task.

### Steps

1. Clone the repo: `git clone https://github.com/wemux-ai/wemux.git`, then `cd wemux` and run `pnpm install`.
2. Start infrastructure with `pnpm dev:infra:up`.
3. Copy the env template with `cp .env.development.local.example .env.development.local` and set DATABASE_URL and OBJECT_STORAGE_* to match your setup.
4. Run `pnpm dev:server` (API on :8989) and `pnpm dev:client` (web console) in separate terminals.
5. Run `pnpm dev:worker`, pair the worker with the control plane, then create a task.

### Prompt to paste into your agent

```text
In the wemux repo at <repo-path>, follow the Quick start (self-hosted) steps to start infrastructure, server, client and worker. Report the console URL and confirm the worker shows as paired in the console.
```

### Caveat

The README says a single `pnpm dev` command runs server, console and worker together, but the step-by-step path is the documented one for first setup.

Dual-use notice: only use this on software, sites and systems you own or are authorized to test.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/wemux-ai-wemux/run-local-agent-control-plane/

## How to add a worker on a second Mac or Linux machine with Wemux

Repo: [wemux-ai/wemux](https://github.com/wemux-ai/wemux) | Difficulty: Intermediate | Time: 15 minutes | Basis: From the README

Install and pair a remote worker using the command generated in the console's Add Executor dialog.

**Who it is for:** A team lead with spare Mac or Linux machines who wants agent work to run on those machines instead of the server.

**The problem:** Coding agents need a machine with your repos and credentials, which is often not the control plane host.

**The outcome:** A registered worker service on another machine that is ready to receive tasks.

### Steps

1. Open the control plane console and go to Execution, then choose Add Executor.
2. Copy the generated install command. It has the form `curl -fsSL https://<server>/install | bash -s -- --pairing-code '<code>' --server-url '<url>'`. (inferred, check the README)
3. On the worker machine, run the copied command in a macOS or Linux shell.
4. Wait for the install to finish; the command installs, pairs, registers and starts the worker service.
5. Confirm the new worker appears in the console's Execution view.

### Prompt to paste into your agent

```text
Using the wemux console at <control-plane-url>, generate an Add Executor install command and run it on <worker-host>. Report whether the worker registers and appears under Execution.
```

### Caveat

The README shows the install command with blank placeholders, so use the exact command the console generates rather than retyping it.

Risk, remote script: The install command pipes a script from your control plane into bash, so run it only from a console you trust.

Dual-use notice: only use this on software, sites and systems you own or are authorized to test.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/wemux-ai-wemux/add-worker-on-another-machine/

## How to deploy your own Wemux instance on Railway with Wemux

Repo: [wemux-ai/wemux](https://github.com/wemux-ai/wemux) | Difficulty: Advanced | Time: 1 hour | Basis: From the README

Provision the control plane, Postgres and a bucket on Railway from the repo's infrastructure-as-code file.

**Who it is for:** A small team without a VPS that wants a hosted copy of Wemux it controls.

**The problem:** Running the control plane usually means managing a server, database and object storage yourself.

**The outcome:** A public control plane URL with a passing /api/ready health check.

### Steps

1. Clone the repo and install dependencies: `git clone https://github.com/wemux-ai/wemux.git && cd wemux` then `pnpm install`.
2. Log in and set up the project with `railway login`, then `railway init` (or `railway link` for an existing project).
3. Provision services with `railway config apply`, then deploy the current checkout with `railway up`.
4. Set BETTER_AUTH_SECRET, TOKEN_SECRET, SECRET_ENCRYPTION_KEY, object storage variables and the public base URL variables on the control-plane service, then redeploy.
5. Verify `https://<your-app>/api/ready`, open /execution, and run Add Executor on a worker machine.

### Prompt to paste into your agent

```text
In the wemux repo at <repo-path>, deploy the control plane to Railway with the documented commands. Report the public HTTPS origin and confirm that /api/ready returns a healthy response.
```

### Caveat

The README warns that a plain Deploy from GitHub repo misdetects the project and crashes, so use the infrastructure-as-code flow.

Risk, credentials: This setup needs several secret keys and object storage credentials; generate them with openssl and store them only in Railway variables.

Dual-use notice: only use this on software, sites and systems you own or are authorized to test.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/wemux-ai-wemux/deploy-own-instance-on-railway/

## How to delegate coding tasks to agents on your own workers with Wemux

Repo: [wemux-ai/wemux](https://github.com/wemux-ai/wemux) | Difficulty: Intermediate | Time: 45 minutes | Basis: From the README

Describe a coding task in the main chat and have an agent run it in an isolated worktree for review.

**Who it is for:** A developer with a paired worker and a BYOK model setup who wants routine code changes done while they review the results.

**The problem:** Small coding tasks wait in a backlog, and running agents on a shared cloud box raises questions about where code and keys go.

**The outcome:** A diff from an isolated branch that you review and approve before anything is merged.

### Steps

1. Configure OpenCode, Claude Code or Codex on the worker with your own keys, then select models in the console's model center.
2. Open the main chat and describe the task in natural language, or create a kanban task in a workspace.
3. Let the main agent pick an agent and workspace and route the task to an available worker.
4. When the worker reports back, review the diff and results in the workspace session.
5. Approve the changes you want; approved changes are delivered and each step stays traceable.

### Prompt to paste into your agent

```text
Using the Wemux console at <control-plane-url>, create a task in workspace <workspace-name> asking an agent to <task-description>. Report the worker that ran it, the diff summary, and confirm nothing merged before approval.
```

### Caveat

The README describes the review and approval flow but not the exact approval controls, so check the console for the current steps.

Risk, credentials: Your model keys stay on the worker, so protect that machine and its runtime configuration like any credential store.

Dual-use notice: only use this on software, sites and systems you own or are authorized to test.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/wemux-ai-wemux/delegate-coding-tasks-to-workers/

## How to create agent tasks from Feishu, Slack or DingTalk with Wemux

Repo: [wemux-ai/wemux](https://github.com/wemux-ai/wemux) | Difficulty: Advanced | Time: 1 hour | Basis: From the README

Send a request from a team chat channel so the main agent turns it into a task for a worker.

**Who it is for:** A team that already coordinates in Slack, Feishu, DingTalk, WeCom, WeChat or WhatsApp and wants requests to reach agents without switching tools.

**The problem:** Engineering requests often start in chat, then get retyped into a separate task tool.

**The outcome:** A task created from a chat message that appears in the workspace and is routed to a worker.

### Steps

1. In the Wemux console, connect the channel integration you need, such as Slack or Feishu, following the setup in docs/SELF-HOSTING.md. (inferred, check the README)
2. Confirm the channel is configured for inbound messages. (inferred, check the README)
3. Send a natural-language request in the connected channel describing the task.
4. Check the workspace kanban for the new task and confirm the main agent picked an agent and workspace.
5. Review the worker's diff and approve or reject it in the workspace session.

### Prompt to paste into your agent

```text
Send the request '<task-description>' through the connected <channel-name> integration in Wemux. Verify that a matching task appears in workspace <workspace-name> and report which worker received it.
```

### Caveat

The README lists the channels but does not describe their setup steps, so the setup steps here are inferred and need checking against the docs.

Risk, credentials: Connecting a chat channel means giving Wemux access to a team messaging account, so use a dedicated bot or app identity.

Dual-use notice: only use this on software, sites and systems you own or are authorized to test.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/wemux-ai-wemux/create-tasks-from-team-chat/
