DEV Community

Cover image for Qwen Live Delivery Plugin: How to Run Long Agent Tasks You Can Steer
Hassann
Hassann

Posted on Originally published at apidog.com

Qwen Live Delivery Plugin: How to Run Long Agent Tasks You Can Steer

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+.

Try Apidog today

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.

Qwen Live Delivery Plugin

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_begin starts the task with the full objective, a title and one first milestone. Each milestone carries an id, scope, acceptance criteria and a target_after time measured from task start.
  • ld_publish freezes a version: the files, an explicit preview_entry (an index.html for a site, for example), a change note and a list of checks. Each check has a label, a result of passed, failed or not_run, and optional evidence.
  • ld_status reads the plan, remaining budget, queued feedback and stop state, or posts a one-line public activity message to the workbench.
  • ld_done closes 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

Diagram of the Live Delivery loop

Here’s the loop in order:

  1. You type a $ld:go request with the outcome you want.
  2. The agent calls ld_begin with the full objective and one first milestone. No separate plan approval step.
  3. It builds the milestone and runs that milestone’s acceptance checks.
  4. It calls ld_publish, which freezes version 1 with its files and preview entry.
  5. You open the workbench, try the version, and type changes on the left panel.
  6. The agent replans: it compares the delivery with the full objective, folds in your feedback and calls ld_begin with the next milestone.
  7. 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
Enter fullscreen mode Exit fullscreen mode

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-only installs without opening Codex
  • --doctor checks 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
Enter fullscreen mode Exit fullscreen mode

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.
Enter fullscreen mode Exit fullscreen mode

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:

  1. After the first delivery, select a version on the right and open Files to preview or download individual files.
  2. Add requirements on the left. Enter sends; Shift+Enter adds a newline.
  3. 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.

Diagram of a coding agent running apidog run

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
Enter fullscreen mode Exit fullscreen mode

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.
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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)