qwen-agent

qwen-agent

Offload menial, self-contained tasks to a Qwen model running inside a headless Claude Code instance (claude-9arm). Keeps expensive Claude reasoning for work that needs it.

The command

claude-9arm is a shell alias → claude --model qwen3.6-35b-a3b routed through the 9arm gateway. Run it headless with -p:

claude-9arm -p "<self-contained task prompt>" --allowedTools Bash Read Edit Write Glob Grep

• This is the default invocation. The flag list scopes which tools the subagent may use without a prompt, so it can finish a menial job unattended. Without it the subagent stalls waiting for approval on the first edit or command.
• The alias bakes in --allowedTools '*', which Claude Code silently ignores with a warning (Wildcard tool name "*" is not supported). That warning is expected and harmless — the --allowedTools you append is what takes effect.
• For edit-only, lower-risk tasks you may instead use --permission-mode acceptEdits (auto-accepts file edits, but Bash still prompts — don't use it for verification/build/test runs).

Writing the task prompt (most important step)

The qwen subagent has zero context from this conversation. A vague prompt is the #1 failure mode. Every prompt must be standalone:

• Absolute paths for every input and output file (/Users/tpatinya/proj/src/foo.ts, not foo.ts).
• Explicit inputs, outputs, and acceptance criteria — what to change, what "done" looks like.
• No references to "the file we discussed", "above", or prior turns.
• Treat qwen as a capable-but-literal junior: spell out the steps, keep scope tight.

Bad: clean up the imports Good: In /Users/tpatinya/proj/src/api.ts, remove unused imports and sort the remaining import statements alphabetically. Do not change any other code. Confirm the file still parses.

Mind the context window (128k)

Qwen runs with a 128k-token context window — much smaller than Claude's. The whole job (your prompt + every file it reads + its own reasoning and edits) has to fit inside it. Size each delegated task to the model, not just to "is it menial":

• Estimate the footprint before delegating: roughly the bytes of files it must read + open + write, ÷ 4 ≈ tokens. If a single task would pull in large files or many files at once, it won't fit.
• Break large jobs into independent chunks that each touch a bounded slice — e.g. one file (or a few small ones) per run, one directory per run, one log segment per run. Run the chunks as separate claude-9arm invocations (foreground, or background-parallel per the Return contract section).
• Don't make it read what it doesn't need. Point it at the exact files/paths required; never tell it to "scan the repo" or read a whole large tree.
• Watch for context-exhaustion symptoms when verifying: truncated edits, ignored later instructions, or a summary that omits files it was told to touch usually mean the task overflowed — split it smaller and retry.

When a job is inherently too big to slice cleanly (it needs whole-codebase context to do correctly), that's a sign it isn't a qwen task — keep it yourself.

Working directory

The Bash tool's cd resets between calls and cd && can trip permission prompts. Don't rely on cwd:

• Put absolute paths in the prompt, or
• Pass --add-dir /abs/path to grant the subagent access to a directory.

Return contract

• Default (text): qwen's final message prints to stdout — read it directly.

• Need to parse the result: add --output-format json and extract the result field.

• Background / parallel (run several at once): redirect to a log and run with the Bash tool's run_in_background: true, then read the log when it finishes:

  claude-9arm -p "<task>" --allowedTools Bash Read Edit Write Glob Grep > /tmp/qwen-<label>.log 2>&1

  Launch independent tasks as separate background runs; collect each log on completion. Use this when delegating 2+ unrelated menial jobs.

Workflow checklist

1. Confirm the task is menial and low-risk (see description). If it needs design judgment or this chat's context, do it yourself — don't delegate.
2. Check it fits qwen's 128k context window — estimate the file footprint and split large jobs into bounded per-file/per-dir chunks (see "Mind the context window").
3. Write a fully self-contained prompt with absolute paths and acceptance criteria.
4. Run claude-9arm -p "..." --allowedTools Bash Read Edit Write Glob Grep (foreground), or background-redirect for parallel jobs.
5. Verify the output yourself — qwen is cheaper and less reliable. Check the file/result actually meets the acceptance criteria before reporting success.

One-time setup (optional, removes repeated prompts)

To stop per-call permission prompts on delegated runs, add a Bash allow rule for the command (via the update-config skill, or by editing settings):

{ "permissions": { "allow": ["Bash(claude-9arm:*)"] } }

When NOT to delegate

Architecture/design, debugging that needs reasoning, security-sensitive changes, anything requiring this conversation's context, or tasks where a wrong cheap-model edit is costly to catch. When in doubt, keep it.