The Qwen Live Delivery Plugin is an open-source Codex CLI plugin from the Qwen team that makes a long agent task ship a usable first version early, then improve it one version at a time while you add requirements from a browser workbench. It’s Apache-2.0, version 0.1.0, and runs on Linux and macOS with Node.js 22+.
That’s the short answer. The rest of this guide covers what’s inside the plugin, how to install it, how time budgets work, the sandbox setting you shouldn’t flip casually, and how to make your agent prove every delivered version against a real API with Apidog CLI.
What is the Qwen Live Delivery Plugin?
The Qwen Live Delivery Plugin is a lightweight add-on for long-running coding agent tasks. Instead of letting the agent work in a black box for an hour, it forces a rhythm: plan a small usable milestone, build it, check it, publish a frozen version, then plan the next one from the results and your feedback. You can steer at any point.
Alibaba’s Qwen team released it alongside the general release of Qwen4-Max on 2026-11-16, where the launch post calls the idea “Live Delivery”: ship a working version early, then keep improving it release by release while the user steers. If you need the model background first, read what Qwen4-Max is and how to use Qwen4-Max.
The payoff: a wrong turn costs one version, not the whole run, because a usable artifact stays on the table the whole time.
What’s inside the plugin
The Qwen-Live-Delivery-Plugin repository contains four parts that work together:
| Part | What it is | What it does |
|---|---|---|
| Live Delivery skill | $ld:go |
Tells the agent to pick a minimal usable first version, plan each next version from actual results, and run checks in every iteration |
| MCP server |
ld_begin, ld_publish, ld_status, ld_done
|
Manages the delivery plan, freezes version snapshots with a preview entry, reports remaining budget, wraps up |
| Lifecycle hooks |
SessionStart, UserPromptSubmit, PostToolUse, Stop, Interrupt, SessionEnd
|
Feed your feedback into context, block early “I’m done” turns while budget remains, support wrap-up |
| Browser workbench | Local web UI | Shows the plan, previews and downloads versions, takes new requirements, adjusts the budget or stops the task |
The four MCP tools are the protocol the skill follows:
-
ld_beginstarts the task with the full objective, a title and one first milestone. Each milestone carries an id, scope, acceptance criteria and atarget_aftertime measured from task start. -
ld_publishfreezes a version: the files, an explicitpreview_entry(anindex.htmlfor a site, for example), a change note and a list ofchecks. Each check has alabel, aresultofpassed,failedornot_run, and optionalevidence. -
ld_statusreads the plan, remaining budget, queued feedback and stop state, or posts a one-line public activity message to the workbench. -
ld_donecloses the task with a summary.
The skill tells the agent never to mark a failed or unrun check as passed. The host verifies snapshot copies and hashes, but acceptance results stay agent-reported. We’ll close that gap with a real API test later.
The hooks are the steering wheel. For a task started from the browser, the host interrupts the agent and resumes the same Codex thread so your message lands through UserPromptSubmit. For a task started in the CLI, feedback arrives at the next supported tool or turn boundary.
How Live Delivery runs a long task
Here’s the loop in order:
- You type a
$ld:gorequest with the outcome you want. - The agent calls
ld_beginwith the full objective and one first milestone. No separate plan approval step. - It builds the milestone and runs that milestone’s acceptance checks.
- It calls
ld_publish, which freezes version 1 with its files and preview entry. - You open the workbench, try the version, and type changes on the left panel.
- The agent replans: it compares the delivery with the full objective, folds in your feedback and calls
ld_beginwith the next milestone. - Steps 3 to 6 repeat until the budget runs out or you press Stop task. Then it publishes any ready improvement and calls
ld_done.
Two rules stand out. There’s no fixed version count, so the agent decides scope per round based on value. And finishing the planned milestones doesn’t end the task while authorized time remains: the agent keeps finding the next useful improvement.
How to install the Qwen Live Delivery Plugin
Check the requirements first:
- Codex CLI (the only harness at launch; tested with Codex 0.166.0 and 0.167.1)
- Linux or macOS
- Node.js 22 or newer
The plugin ships no model and no API key. It uses your existing Codex model, authentication and approval settings. See OpenAI’s Codex CLI documentation if you haven’t set Codex up yet.
Clone the repository and run the installer against your project:
git clone https://github.com/QwenLM/Qwen-Live-Delivery-Plugin.git
cd Qwen-Live-Delivery-Plugin
./live-delivery/install.sh --workspace /path/to/project
Press Enter and it installs the plugin, configures the hooks and opens Codex. The release needs no npm install. If Codex was already open, start a new session.
Useful installer flags:
-
--install-onlyinstalls without opening Codex -
--doctorchecks an existing install
You can also ask Codex to read the README and follow its installation skill; after install, $ld:install handles setup and diagnosis. To uninstall, run codex plugin remove ld@live-delivery-local --json and codex plugin marketplace remove live-delivery-local --json. Your workspaces and delivery records stay.
Quick start: your first steerable task
Start Codex in your project with a time budget:
cd /path/to/project
QWEN_LD_TIME_BUDGET=12m codex
Then type the request. The README’s example:
$ld:go Build an offline pendulum experiment. Let me adjust the length, pause the
animation, and understand how length affects the period. Make it work on mobile too.
The CLI prints a workbench URL. Open it. That link grants access to the workbench, so treat it like a password and don’t paste it into tickets or chat. After a restart, use the latest link the CLI prints.
In the workbench:
- After the first delivery, select a version on the right and open Files to preview or download individual files.
- Add requirements on the left. Enter sends; Shift+Enter adds a newline.
- Use Time budget in the header to change the total time, or Stop task to finish.
Time budgets, sandboxing and other settings
The time budget is the total execution time the agent may spend. Set it with QWEN_LD_TIME_BUDGET before you start Codex, or change it later in the workbench header. The values that matter:
| Setting | Value |
|---|---|
| Default budget (no variable set) | 30 minutes (1,800 seconds in the plugin’s config) |
| Accepted units | minutes, hours or days, such as 15m, 3h, 2d
|
| Maximum | 7 days |
| Who can enlarge it | Only you; the model’s tools can’t raise the authorized limit |
| Stop behavior | Waits for the current tool call to finish |
Now the warning. Browser-started tasks default to Codex’s workspace-write sandbox. Setting QWEN_LD_TASK_SANDBOX=danger-full-access disables the sandbox and per-command approval, so the agent can touch anything outside the workspace with your OS account’s permissions. The installer never turns that on for you. Keep the default unless you run inside a disposable VM or container.
Use the workbench on a trusted network. For local-only access or SSH port forwarding, set QWEN_LD_BIND_HOST=127.0.0.1 before starting Codex.
Limits to know before you rely on it
This is a 0.1.0 release, and the README is upfront about its scope:
- Codex CLI only. Support for other agent harnesses is on the to-do list. There’s no date.
- Linux and macOS only. No Windows listing.
- Your model, your quota. The plugin uses whatever model Codex is set to. A seven-day budget on a frontier model burns real money, so check Qwen4-Max pricing or the Qwen4-Max Token Plan if that’s the model behind your harness, or Qwen4-Max for free for the quota routes.
- Checks are self-reported. The host verifies file snapshots, not whether your acceptance criteria really pass.
- CLI tasks get feedback later. CLI-started tasks see browser feedback only at tool or turn boundaries.
Make every delivered version prove itself with Apidog CLI
Live Delivery asks for truthful checks on every version, but a check that says “API works” is only as good as the test behind it. If your agent is building an API, or an app that calls one such as the Qwen4-Max API, let it run a real test with Apidog CLI before each ld_publish and paste the result in as evidence.
Set it up once:
npm install -g apidog-cli@latest
apidog login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com # pick Codex when prompted
Then add one prompt to the $ld:go request, or send it from the workbench mid-task:
Before every ld_publish: in Apidog project <projectId>, keep an environment
"Qwen Singapore" with base URL https://ap-southeast-1.maas.qwencloudapi.com/compatible-mode/v1
and a secret DASHSCOPE_API_KEY. Keep a test case for POST /chat/completions with
model qwen4-max that asserts status 200, a non-empty choices array and a usage object.
Run it, and turn each assertion into an ld_publish check with the report as evidence.
Never mark a failed assertion passed.
The agent reads each payload schema before writing, then runs the case on every version:
apidog environment create "Qwen Singapore" --project <projectId> --base-url https://ap-southeast-1.maas.qwencloudapi.com/compatible-mode/v1
apidog cli-schema get test-case-create
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project <projectId> --file case.json
apidog run --test-case <caseId> --project <projectId> -e <envId> -r cli,json --out-dir ld-reports
The cli reporter prints pass or fail for the log; json writes a report into ld-reports that the agent quotes in each check’s evidence. If your own API is the thing being built, swap the endpoint for yours and add the version’s new routes to the case each round. Add --upload-report to view runs in the Apidog app. For more Codex prompts, see Apidog CLI in Codex, and move the same apidog run ... -r junit into CI with the Apidog CLI CI/CD guide. Apidog’s Free plan covers up to 4 users.
FAQ
Does the Qwen Live Delivery Plugin work with Claude Code or Cursor? Not yet. At launch it supports Codex CLI only. Other harnesses are on the project’s to-do list with no date.
Do I need a Qwen API key to use it? No. The plugin includes no model or key. It runs on the model and authentication your Codex install already uses.
What’s the default time budget? 30 minutes if you don’t set QWEN_LD_TIME_BUDGET. You can set minutes, hours or days, up to 7 days, and change it from the workbench header.
What happens when I press Stop task? The agent finishes the current tool call, starts no new scope, publishes any ready improvement whose checks pass and calls ld_done. Every delivered version stays available.
Is it safe to run with full access? Only in a disposable environment. danger-full-access removes the sandbox and per-command approval. The installer never enables it, and the default workspace-write sandbox is the sensible choice for most work.



Top comments (0)