Agent skill

Zcode Delegate

by sickn33 in sickn33/agentic-awesome-skills

Delegate coding tasks to the Z.AI ZCode CLI only when the user explicitly requests it, while the orchestrator retains review and landing responsibility.

MITAuto-check passed

Install Zcode Delegate

skills CLI
$ npx skills add sickn33/agentic-awesome-skills --skill zcode-delegate -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install sickn33/agentic-awesome-skills zcode-delegate --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/sickn33/agentic-awesome-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/zcode-delegate .claude/skills/zcode-delegate && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
zcode-delegate
GitHub stars
47k
Used in
1 other repo
Token cost
~2.5k tokens
SKILL.md length
1,185 words
Files
5 (incl. references)
Skills in repo
1,394
Repo updated
First seen
Licence
MIT

At a glance

Delegate coding tasks to the Z.AI ZCode CLI only when the user explicitly requests it, while the orchestrator retains review and landing responsibility.

  • Works in 5 steps: Write the brief → Dispatch → Wait for completion → …
  • Explicitly requests it
  • SKILL.md covers When to Use, When NOT to use this, Prerequisites (check once) and Authenticating the headless CLI, plus 6 more sections
  • Calls node; reaches api.z.ai; needs ZAI_API_KEY and ZCODE_API_KEY

What it does

Zcode Delegate is an agent skill from sickn33/agentic-awesome-skills. Delegate coding tasks to the Z.AI ZCode CLI only when the user explicitly requests it, while the orchestrator retains review and landing responsibility.

Its SKILL.md is about 2.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 5 other files, including reference files (for example `references/dispatch-and-poll.md`, `references/multi-task-queues.md` and `references/review-and-land.md`). Compatibility notes: Requires the zcode CLI (Z.AI ZCode) with a configured model provider, Node 18+, and git. ZCode ships its CLI inside the desktop app rather than on PATH or npm…

It works with Zhipu GLM. The repository describes itself as: AAS Core is the local, agent-first control plane for complete catalog discovery, agent-owned selection, stack validation, and planning, backed by 2,400+ agentic skills. Includes… The licence is MIT.

When your agent uses it

  • Explicitly requests it
  • While the orchestrator retains review and landing responsibility

Example prompts

  • “/zcode-delegate”

Requirements

  • A credential in ZAI_API_KEY
  • A credential in ZCODE_API_KEY
  • Compatibility (from SKILL.md): Requires the `zcode` CLI (Z.AI ZCode) with a configured model provider, Node 18+, and git. ZCode ships its CLI inside the desktop app rather than on PATH or npm — see Prerequisites. The orchestrating agent must be able to run shell commands and read files. Shell examples assume bash/zsh (macOS/Linux, or Git Bash/WSL on Windows).

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Write the brief
  2. Dispatch
  3. Wait for completion
  4. Review — do not trust the self-report
  5. Land it

What it can do on your machine

Read from SKILL.md and the folder at commit 1e53ce2. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • node

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • api.z.ai

    Also links to:

    • github.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • ZAI_API_KEY
    • ZCODE_API_KEY
    • ANTHROPIC_API_KEY

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

  • Compatibility

    Requires the `zcode` CLI (Z.AI ZCode) with a configured model provider, Node 18+, and git. ZCode ships its CLI inside the desktop app rather than on PATH or npm — see Prerequisites. The orchestrating agent must be able to run shell commands and read files. Shell examples assume bash/zsh (macOS/Linux, or Git Bash/WSL on Windows).

    From compatibility in the SKILL.md frontmatter.

Context cost

Zcode Delegate loads about 2.5k tokens when it runs, and up to ~7.3k if it reads all its reference files. Until then it costs about 42 tokens; SKILL.md has 1,185 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~42
When it runs · the whole SKILL.md, loaded when a task matches
~2.5k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~7.3k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from sickn33/agentic-awesome-skills at commit 1e53ce2, republished under its MIT licence (© sickn33). 1,185 words, ~2,516 tokens.

Download SKILL.mdSave it as .claude/skills/zcode-delegate/SKILL.md (or your agent's skills folder). This skill also uses 4 other files; get the full folder from GitHub.
name
zcode-delegate
description
Delegate coding tasks to the Z.AI ZCode CLI only when the user explicitly requests it, while the orchestrator retains review and landing responsibility.
compatibility
Requires the `zcode` CLI (Z.AI ZCode) with a configured model provider, Node 18+, and git. ZCode ships its CLI inside the desktop app rather than on PATH or npm — see Prerequisites. The orchestrating agent must be able to run shell commands and read files. Shell examples assume bash/zsh (macOS/Linux, or Git Bash/WSL on Windows).
risk
critical
category
agent-orchestration
source
https://github.com/amElnagdy/delegate-skills
source_repo
amElnagdy/delegate-skills
source_type
community
date_added
2026-08-26
license
MIT
license_source
https://github.com/amElnagdy/delegate-skills/blob/master/LICENSE
metadata.version
0.5.0

ZCode Delegate

When to Use

  • You want to delegate a bounded coding task to a separate zcode implementer (Z.AI ZCode) and then review its diff yourself.
  • The user explicitly asked for delegation to this implementer.

You are the orchestrator. This skill lets you hand a bounded coding task to a separate implementer — the Z.AI ZCode CLI — then review what it produced and land it yourself. You write the brief and own the judgment; ZCode does the typing; you verify and commit.

Nothing here is specific to one orchestrating agent. The loop needs only the ability to run a shell command and read a file. (It is designed for and run on Claude Code; treat other orchestrators as designed-for, not yet proven.)

When NOT to use this

  • The task is small enough to just do inline — delegation overhead is not worth it.
  • ZCode is not installed, or its CLI has no model provider configured.
  • You want to write the code yourself, or you only need a review.

Prerequisites (check once)

  1. ZCode is installed. The CLI ships inside the desktop app — it is not on PATH and not on npm. The relay resolves it in this order: --zcode-path <file> or ZCODE_CLI first, then PATH, then the installed app bundle. On Linux the app is an AppImage with no fixed install path, so the flag or the environment variable is required there — the relay guesses nothing.
  2. A model provider is configured for the CLI, with a key it can actually reach. Being signed into the desktop app is not enough — see below.
  3. You are in (or will point --cd at) the target git repository.

The relay records the CLI version and how it was resolved into result.json, so a surprising install is visible after the fact.

Authenticating the headless CLI

Signing into the ZCode desktop app does not authenticate the CLI this relay drives. The CLI keeps its own config at ~/.zcode/cli/config.json, separate from the desktop app's, and nothing bridges the two. zcode login is the intended path, but where it fails with OAuth response is not valid JSON the way in is a Z.AI API key.

Two pieces are needed, and they are separate:

  1. The provider block must exist in ~/.zcode/cli/config.json. It defines the provider, its endpoint and its models — the environment cannot supply this:

    jsonc
    {
      "provider": {
        "zai": {
          "kind": "anthropic",
          "options": { "apiKeyRequired": true, "baseURL": "https://api.z.ai/api/anthropic" },
          "models": { "glm-5.1": { "name": "GLM-5.1" } }
        }
      },
      "model": { "main": "zai/glm-5.1" }
    }
  2. The key can live either in provider.zai.options.apiKey in that file, or in the environment as any one of ZAI_API_KEY, ZCODE_API_KEY, or ANTHROPIC_API_KEY. Prefer the environment — it keeps the secret off disk.

If a run fails with Model provider is missing an API key: <provider>, the provider block resolved but no key was found: set one of those variables and re-run.

Autonomy — read this before dispatching

ZCode's own term is mode. It has four values; only two are usable headlessly.

modeBehaviour
yoloWrites. ZCode's own default for --prompt, and this relay's write-capable default.
planRefuses edits. What --read-only selects.
buildRejected by this relay. No permission client exists headlessly, so tools are blocked and the run exits 0 having done nothing.
editRejected for the same reason.

Two limits stated plainly, because ZCode cannot enforce them:

  • plan mode refused edits in testing, but the relay does not treat that as a guarantee. It takes a Git fingerprint before the run and reports a tri-state readOnlyViolation afterwards. Confirm touchedFiles came back empty rather than assuming no edits.
  • ZCode has no --allowed-tools. Only the --disallowed-tools denylist exists, and it is genuinely enforced. An explicit allowlisted tool surface is therefore impossible here — do not assume one.

The loop

Run these five steps per task. Steps 1, 4, and 5 are your judgment; 2 and 3 are mechanical.

1. Write the brief

ZCode sees only what you send — no repo memory, no chat history. Everything the task needs goes in the brief: the goal, the current state, what to change, what to leave untouched, the project's actual gate commands (discover them from the repo's CLAUDE.md/AGENTS.md/Makefile — do not assume), and a report contract. Tell ZCode it will not commit. One task per brief. The relay delivers the brief as an attached file, so the command line no longer bounds its length — the model's context window still does. Full guidance and a template: references/writing-the-brief.md.

Show full SKILL.md (479 more words)Show less
2. Dispatch
bash
node "<skill-dir>/scripts/relay.mjs" --brief brief.txt --cd /path/to/repo
# read-only (review/diagnosis, no edits):   add --read-only
# continue a specific session:              add --session <sess_...>  (from result.json; send only the delta brief)
# continue the latest session for --cd:     add --resume-last
# withhold tools (denylist):                add --disallowed-tools "Write,Edit,Bash"
# point at the CLI explicitly:              add --zcode-path /path/to/zcode.cjs
# hard time limit (watchdog):               add --timeout 2h  (default: off)
# see all options:                          node .../relay.mjs --help

(<skill-dir> is this skill's installed directory — the folder containing this SKILL.md.)

The relay writes its artifacts to a temp dir, so the repo under review stays clean. It never commits — see step 5. Mechanics, flags, and the result.json shape: references/dispatch-and-poll.md.

3. Wait for completion

The relay blocks until ZCode finishes, so back it with whatever your orchestrator offers:

  • Claude Code: run the Bash call with run_in_background: true; you are notified on completion.
  • Plain shell / other agents: foreground for short tasks, or background it and poll the result file. The run is done when result.json exists with a status. A pre-run usage error exits 2 and writes no result file, so check the exit code too; a CLI that cannot be found exits 127 but does write a result.json with status zcode_unavailable.

Do not trust progress trackers over reality: read the working tree, not a status line.

4. Review — do not trust the self-report
  • Re-run the project's gates yourself. Never take "gates passed" on faith.
  • Read the diff against the brief: did ZCode do what was asked, nothing more and nothing less? touchedFiles is your starting point.
  • On a --read-only run, check readOnlyViolation and confirm touchedFiles is empty.
  • Run the relevant guard skills on the diff if you have them installed.

Full checklist: references/review-and-land.md.

5. Land it

The orchestrator commits. Only after the gates pass and the diff holds:

  • Commit the verified work yourself, with a clear message.
  • If it needs changes, send a delta brief with --session <sessionId> from the prior result.json, and review again.

Read-only second opinions

The relay doubles as a way to get an adversarial second opinion with no write risk: dispatch --read-only with a brief listing the agreed points, then each contested point with both positions, and ask ZCode to defend or concede each. Because plan mode's guarantee is measured rather than enforced here, verify touchedFiles came back empty instead of assuming no edits.

Authorization model

Delegation is something the human opts into. Once they have, committing verified, gate-passing work is the agreed contract. Two limits: surface, don't absorb (report ZCode's design decisions and defensible-but-unasked turns rather than silently keeping them) and stop for scope changes (if correct completion needs going beyond the brief, ask). The full treatment is in references/review-and-land.md.

References

Limitations

  • Docs-only import — executable scripts/relay.mjs not included; see upstream for full runtime. Requires zcode CLI, Node 18+, git.
  • Relay never commits — it only returns structured result JSON; you review and land the commit.

Adapted from amElnagdy/delegate-skills (MIT) — docs-only, runtime not bundled.

© sickn33, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 4 other files (references) in skills/zcode-delegate of sickn33/agentic-awesome-skills.

  • SKILL.md
  • references/dispatch-and-poll.md
  • references/multi-task-queues.md
  • references/review-and-land.md
  • references/writing-the-brief.md

Open the folder on GitHubat commit 1e53ce2

Used in 1 other repository

We found 5 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 1 other GitHub owner. This page covers the copy in sickn33/agentic-awesome-skills, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Zcode Delegate next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Zcode Delegate compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Zcode Delegate this skillsickn33/agentic-awesome-skills47k1 repos~2.5kAutomated safety check: PassMIT
Higress Openclaw Integrationhigress-group/higress9.5k—~2.5kAutomated safety check: PassApache-2.0
Image Generationjjyaoao/HelloAgents3.2k1 repos~3.8kAutomated safety check: PassMIT
Adversarial Speczscole/adversarial-spec5561 repos~8.3kAutomated safety check: NotesMIT
Weave Router Local Testingweave-os/router5.6k—~3.1kAutomated safety check: NotesApache-2.0
Video Understandjjyaoao/HelloAgents3.2k1 repos~6.2kAutomated safety check: PassMIT

Similar skills

  • Higress Openclaw Integration

    higress-group/higress

    Deploy and configure Higress AI Gateway for OpenClaw integration.

    9.5k GitHub stars~2.5k tokensUpdated 2 days ago
    AI & LLM EngineeringAuto-check passed
  • Image Generation

    jjyaoao/HelloAgents

    Implement AI image generation capabilities using the z-ai-web-dev-sdk.

    3.2k GitHub starsUsed in 1 repo~3.8k tokens
    Media & CreativeAuto-check passed
  • Adversarial Spec

    zscole/adversarial-spec

    Iteratively refine a product spec by debating with multiple LLMs (GPT, Gemini, Grok, etc.) until all models agree.

    556 GitHub starsUsed in 1 repo~8.3k tokens
    Product & Project ManagementAuto-check: notes
  • Stands up the Weave model router in Docker Compose and drives it with claude -p against a real or mocked upstream to reproduce and verify routing and streaming behavior.

    5.6k GitHub stars~3.1k tokensUpdated today
    DevOps & CloudAuto-check: notes
  • Video Understand

    jjyaoao/HelloAgents

    Implement specialized video understanding capabilities using the z-ai-web-dev-sdk.

    3.2k GitHub starsUsed in 1 repo~6.2k tokens
    AI & LLM EngineeringAuto-check passed
  • AI Model Nodejs

    TencentCloudBase/CloudBase-AI-Toolkit

    A skill your agent uses for Node.js backend AI via @cloudbase/node-sdk (=3.16.0) — cloud functions, CloudRun, Express/Koa/NestJS, serverless APIs, scheduled jobs, LLM proxies, agent orchestration.

    1.1k GitHub starsUsed in 3 repos~5k tokens
    Backend & APIsAuto-check passed

More from sickn33/agentic-awesome-skills

All 1,394 skills in this repo
  • Liuguang Banlan UI

    sickn33/agentic-awesome-skills

    Implements an interface in one of two named color modes, iridescent white or colorful black, from a parameterized starter that reports measured color intensity.

    47k GitHub starsUsed in 1 repo~2.5k tokens
    Auto-check passed
  • User Thoughts Memory

    sickn33/agentic-awesome-skills

    Saves a user's project decisions, rules and preferences into a project-local mdbase so later sessions and other agents can recover the intent.

    47k GitHub starsUsed in 1 repo~2.5k tokens
    Auto-check passed
  • Using LWC Memory and Graphs

    sickn33/agentic-awesome-skills

    Keeps project decisions, research and verified results available across coding-agent sessions through LWC memory, a document Wiki graph and a CodeGraph code index.

    47k GitHub starsUsed in 1 repo~2k tokens
    Auto-check passed
  • Find Complementary Founders

    sickn33/agentic-awesome-skills

    Guides an agent through assessing its own owner for cofounder fit, publishing an approved profile, and ranking complementary profiles other agents published for their owners.

    47k GitHub starsUsed in 1 repo~4.8k tokens
    Auto-check passed
  • Whatsapp Cloud API

    sickn33/agentic-awesome-skills

    Integracao com WhatsApp Business Cloud API (Meta). An agent skill from sickn33/agentic-awesome-skills.

    47k GitHub starsUsed in 2 repos~4.5k tokens
    Auto-check passed
  • Cline Pilot

    sickn33/agentic-awesome-skills

    Acts as a proxy for the Cline CLI, dispatching coding tasks one at a time, monitoring runs by hard evidence, relaying decisions to you and learning per-project preferences.

    47k GitHub starsUsed in 1 repo~4.6k tokens
    Auto-check passed

Works with

Questions about Zcode Delegate

What does Zcode Delegate do?

Delegate coding tasks to the Z.AI ZCode CLI only when the user explicitly requests it, while the orchestrator retains review and landing responsibility. Zcode Delegate is an agent skill from sickn33/agentic-awesome-skills.AI ZCode CLI only when the user explicitly requests it, while the orchestrator retains review and landing responsibility.

When should I use Zcode Delegate?

Zcode Delegate fits situations like: explicitly requests it; while the orchestrator retains review and landing responsibility.

How do I install Zcode Delegate in Claude Code?

Run `npx skills add sickn33/agentic-awesome-skills --skill zcode-delegate -a claude-code`. Or copy the skill folder (skills/zcode-delegate in sickn33/agentic-awesome-skills) into .claude/skills/zcode-delegate in your project. Claude Code loads it when a task matches its description.

How do I install Zcode Delegate in Codex?

Run `npx skills add sickn33/agentic-awesome-skills --skill zcode-delegate -a codex`. Or copy the skill folder (skills/zcode-delegate in sickn33/agentic-awesome-skills) into .agents/skills/zcode-delegate in your project. Codex loads it when a task matches its description.

Can I use Zcode Delegate in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add sickn33/agentic-awesome-skills --skill zcode-delegate -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/zcode-delegate, .gemini/skills/zcode-delegate, .github/skills/zcode-delegate and .opencode/skills/zcode-delegate in your project.

What does Zcode Delegate need to run?

Going by SKILL.md and its folder, Zcode Delegate needs the command-line tools its instructions call (node) and credentials named ZAI_API_KEY, ZCODE_API_KEY and ANTHROPIC_API_KEY. Our summary lists: A credential in ZAI_API_KEY; A credential in ZCODE_API_KEY. Compatibility (from SKILL.md): Requires the `zcode` CLI (Z.AI ZCode) with a configured model provider, Node 18+, and git. ZCode ships its CLI inside the desktop app rather than on PATH or npm — see Prerequisites. The orchestrating agent must be able to run shell commands and read files. Shell examples assume bash/zsh (macOS/Linux, or Git Bash/WSL on Windows)..

Does Zcode Delegate access the network?

SKILL.md names 2 domains. In commands or code: api.z.ai; the agent is likely to contact it when it follows the instructions. As links in the text: github.com. This is read from the text; nothing was executed.

Is Zcode Delegate safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Zcode Delegate use?

Zcode Delegate is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Zcode Delegate use?

About 2.5k tokens (SKILL.md is roughly 10k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 4.8k tokens, read only when the agent opens those files.

What are the alternatives to Zcode Delegate?

Skills that share tags, products or a category with Zcode Delegate: Higress Openclaw Integration (higress-group/higress, 9.5k stars), Image Generation (jjyaoao/HelloAgents, 3.2k stars), Adversarial Spec (zscole/adversarial-spec, 556 stars) and Weave Router Local Testing (weave-os/router, 5.6k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Zcode Delegate?

sickn33 (a GitHub user) maintains it in sickn33/agentic-awesome-skills, which has 47,304 GitHub stars. The repository holds 1,394 skills in this directory. The repository was last updated on October 6, 2026.

Source: sickn33/agentic-awesome-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.