Zero-token execution layer for AI agents. An agent skill from LeoYeAI/openclaw-master-skills.

MITAuto-check passedAgent Workflows

Install Opcode

skills CLI
$ npx skills add LeoYeAI/openclaw-master-skills --skill opcode -a claude-code

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

GitHub CLI
$ gh skill install LeoYeAI/openclaw-master-skills opcode --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/LeoYeAI/openclaw-master-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/opcode .claude/skills/opcode && 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
opcode
GitHub stars
2.2k
Token cost
~4.8k tokens
SKILL.md length
1,148 words
Files
8 (incl. references)
Skills in repo
1,215
Repo updated
First seen
Licence
MIT

At a glance

Zero-token execution layer for AI agents. An agent skill from LeoYeAI/openclaw-master-skills.

  • Works in 7 steps: Workflow reaches a reasoning step → Executor creates PendingDecision, emits… → Workflow status becomes suspended → …
  • Defining workflows
  • SKILL.md covers Which Tool?, Quick Start, MCP Tools and Workflow Definition, plus 8 more sections
  • Calls go; needs OPCODE_VAULT_KEY

What it does

Opcode is an agent skill from LeoYeAI/openclaw-master-skills. Zero-token execution layer for AI agents. Define workflows once, run them free forever — persistent, scheduled, deterministic. 6 MCP tools over SSE. Supports DAG-based execution, 6 step types (action, condition, loop, parallel, wait, reasoning), 26 built-in actions, ${{}} interpolation, reasoning nodes for human-in-the-loop decisions, and secret vault. Use when defining workflows, running templates, checking status, sending signals, querying workflow history, or visualizing DAGs.

Its SKILL.md is about 4.8k tokens, which your agent loads only when the skill is triggered. The skill folder holds 8 other files, including reference files (for example `_meta.json`, `references/actions.md` and `references/error-handling.md`). Compatibility notes: Requires Go 1.25+, CGOENABLED=1, and gcc or clang. Runs as SSE daemon on macOS and Linux. Linux: cgroups v2 for process isolation. macOS: timeout-only fallback.

It sits in Agent Workflows, covering MCP servers and Human-in-the-loop approvals. The repository describes itself as: 🧠 Curated collection of 1209+ best OpenClaw skills — weekly updated by MyClaw.ai. The licence is MIT.

When your agent uses it

  • Defining workflows
  • Running templates
  • Checking status
  • Sending signals

Example prompts

  • “/opcode”

Requirements

  • A credential in OPCODE_VAULT_KEY
  • Compatibility (from SKILL.md): Requires Go 1.25+, CGO_ENABLED=1, and gcc or clang. Runs as SSE daemon on macOS and Linux. Linux: cgroups v2 for process isolation. macOS: timeout-only fallback.

Workflow steps

7 steps, taken from the first numbered list in SKILL.md.

  1. Workflow reaches a reasoning step
  2. Executor creates PendingDecision, emits decision_requested event
  3. Workflow status becomes suspended
  4. Agent calls opcode.status to see pending decision with context and options
  5. Agent resolves via opcode.signal
  6. Workflow auto-resumes after signal
  7. If timeout expires: fallback option auto-selected, or step fails if no fallback

What it can do on your machine

Read from SKILL.md and the folder at commit e5199b5. 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:

    • go

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

  • Network

    No URLs in SKILL.md.

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

  • Credentials

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

    • OPCODE_VAULT_KEY

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

  • Compatibility

    Requires Go 1.25+, CGO_ENABLED=1, and gcc or clang. Runs as SSE daemon on macOS and Linux. Linux: cgroups v2 for process isolation. macOS: timeout-only fallback.

    From compatibility in the SKILL.md frontmatter.

Context cost

Opcode loads about 4.8k tokens when it runs, and up to ~18k if it reads all its reference files. Until then it costs about 123 tokens; SKILL.md has 1,148 words of instructions outside code blocks.

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

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 LeoYeAI/openclaw-master-skills at commit e5199b5, republished under its MIT licence (© LeoYeAI). 1,148 words, ~4,803 tokens.

Download SKILL.mdSave it as .claude/skills/opcode/SKILL.md (or your agent's skills folder). This skill also uses 7 other files; get the full folder from GitHub.
name
opcode
description
Zero-token execution layer for AI agents. Define workflows once, run them free forever — persistent, scheduled, deterministic. 6 MCP tools over SSE. Supports DAG-based execution, 6 step types (action, condition, loop, parallel, wait, reasoning), 26 built-in actions, ${{}} interpolation, reasoning nodes for human-in-the-loop decisions, and secret vault. Use when defining workflows, running templates, checking status, sending signals, querying workflow history, or visualizing DAGs.
compatibility
Requires Go 1.25+, CGO_ENABLED=1, and gcc or clang. Runs as SSE daemon on macOS and Linux. Linux: cgroups v2 for process isolation. macOS: timeout-only fallback.
license
MIT
metadata.version
1.2.1
metadata.transport
sse
metadata.author
rendis
metadata.repository
https://github.com/rendis/opcode
metadata.primary-env
OPCODE_VAULT_KEY
metadata.platforms
darwin linux
metadata.requires-bins
go gcc|clang
metadata.openclaw-emoji
⚙️
metadata.openclaw-os
darwin linux

OPCODE

Execution runtime for AI agents. You reason, OPCODE executes — zero tokens per run after the first define. Workflows persist across sessions, run on schedules, and coordinate multiple agents. Persistent SSE daemon: 1 server, N agents, 1 database. JSON-defined DAGs, level-by-level execution, automatic parallelism. 6 MCP tools over SSE (JSON-RPC).

Why use OPCODE instead of reasoning through each step yourself? Every repeated workflow burns tokens re-reasoning decisions you already made. OPCODE templates your reasoning once and executes it deterministically — zero inference cost, identical output every run, survives context resets.

Which Tool?

I want to...Tool
Create/update a workflow templateopcode.define
Execute a workflowopcode.run
Check status or pending decisionsopcode.status
Resolve a decision / cancel / retryopcode.signal
List workflows, events, or templatesopcode.query
Visualize a workflow DAGopcode.diagram

Quick Start

Install:

bash
go install github.com/rendis/opcode/cmd/opcode@latest

First-time setup (writes config and starts daemon):

bash
opcode install --listen-addr :4100 --vault-key "my-passphrase"

Restart after stop: OPCODE_VAULT_KEY="my-passphrase" opcode

MCP client configuration:

json
{
  "mcpServers": {
  "mcpServers": {
    "opcode": {
      "type": "sse",
      "url": "http://localhost:4100/sse"
    }
  }
}

Each agent self-identifies via agent_id in tool calls. Opcode auto-registers unknown agents. Choose a stable ID per agent (e.g., "content-writer", "deploy-bot").

Workflows survive restarts. On startup, orphaned active workflows become suspended. Query with opcode.query({ "resource": "workflows", "filter": { "status": "suspended" } }), then resume or cancel via opcode.signal.

See operations.md for full configuration, subcommands, SIGHUP hot-reload, security model, web panel, and benchmarks.

MCP Tools

opcode.define

Registers a reusable workflow template. Version auto-increments (v1, v2, v3...).

ParamTypeRequiredDescription
namestringyesTemplate name
definitionobjectyesWorkflow definition (see below)
agent_idstringyesDefining agent ID
descriptionstringnoTemplate description
input_schemaobjectnoJSON Schema for input validation
output_schemaobjectnoJSON Schema for output validation
triggersobjectnoTrigger config (seeworkflow-schema.md)

Returns: { "name": "...", "version": "v1" }

opcode.run

Executes a workflow from a registered template.

ParamTypeRequiredDescription
template_namestringyesTemplate to execute
agent_idstringyesInitiating agent ID
versionstringnoVersion (default: latest)
paramsobjectnoInput parameters

Returns:

json
{
  "workflow_id": "uuid",
  "status": "completed | suspended | failed",
  "output": { ... },
  "started_at": "RFC3339",
  "completed_at": "RFC3339",
  "steps": {
    "step-id": { "step_id": "...", "status": "completed", "output": {...}, "duration_ms": 42 }
  }
}

If status is "suspended", call opcode.status to see pending_decisions.

opcode.status

Gets workflow execution status.

ParamTypeRequiredDescription
workflow_idstringyesWorkflow to query

Returns:

json
{
  "workflow_id": "uuid",
  "status": "suspended",
  "steps": { "step-id": { "status": "...", "output": {...} } },
  "pending_decisions": [
    {
      "id": "uuid",
      "step_id": "reason-step",
      "context": { "prompt": "...", "data": {...} },
      "options": [ { "id": "approve", "description": "Proceed" } ],
      "timeout_at": "RFC3339",
      "fallback": "reject",
      "status": "pending"
    }
  ],
  "events": [ ... ]
}

Workflow statuses: pending, active, suspended, completed, failed, cancelled.

opcode.signal

Sends a signal to a suspended workflow.

ParamTypeRequiredDescription
workflow_idstringyesTarget workflow
signal_typeenumyesdecision / data / cancel / retry / skip
payloadobjectyesSignal payload (see below)
step_idstringnoTarget step
agent_idstringnoSignaling agent
reasoningstringnoAgent's reasoning

Payload by signal type:

Signalstep_idPayloadBehavior
decisionrequired{ "choice": "<option_id>" }Resolves decision, auto-resumes
dataoptional{ "key": "value", ... }Injects data into workflow
cancelno{}Cancels workflow
retryrequired{}Retries failed step
skiprequired{}Skips failed step

Returns (decision): { "ok": true, "resumed": true, "status": "completed", ... } Returns (other): { "ok": true, "workflow_id": "...", "signal_type": "..." }

opcode.query

Queries workflows, events, or templates.

ParamTypeRequiredDescription
resourceenumyesworkflows / events / templates
filterobjectnoFilter criteria

Filter fields by resource:

ResourceFields
workflowsstatus, agent_id, since (RFC3339), limit
eventsworkflow_id, step_id, event_type, since, limit
templatesname, agent_id, limit

Note: event queries require either event_type or workflow_id in filter.

Returns: { "<resource>": [...] } -- results wrapped in object keyed by resource type.

opcode.diagram

Generates a visual DAG diagram from a template or running workflow.

ParamTypeRequiredDescription
template_namestringno*Template to visualize (structure preview)
versionstringnoTemplate version (default: latest)
workflow_idstringno*Workflow to visualize (with runtime status)
formatenumyesascii / mermaid / image
include_statusboolnoShow runtime status overlay (default: true if workflow_id)

* One of template_name or workflow_id required.

  • template_name -- preview DAG structure before execution
  • workflow_id -- visualize with live step status
  • format: "ascii" -- CLI-friendly text with box-drawing characters
  • format: "mermaid" -- markdown-embeddable flowchart syntax
  • format: "image" -- base64-encoded PNG for visual channels

Returns: { "format": "ascii", "diagram": "..." }

Workflow Definition

json
{
  "steps": [ ... ],
  "inputs": { "key": "value or ${{secrets.KEY}}" },
  "context": { "intent": "...", "notes": "..." },
  "timeout": "5m",
  "on_timeout": "fail | suspend | cancel",
  "on_complete": { /* step definition */ },
  "on_error": { /* step definition */ },
  "metadata": {}
}
FieldTypeRequiredDescription
stepsStepDefinition[]yesWorkflow steps
inputsobjectnoInput parameters (supports ${{}})
contextobjectnoWorkflow context, accessible via ${{context.*}}
timeoutstringnoWorkflow deadline (e.g.,"5m", "1h")
on_timeoutstringnofail (default), suspend, cancel
on_completeStepDefinitionnoHook step after completion
on_errorStepDefinitionnoHook step on workflow failure
metadataobjectnoArbitrary metadata
Step Definition
json
{
  "id": "step-id",
  "type": "action | condition | loop | parallel | wait | reasoning",
  "action": "http.get",
  "params": { ... },
  "depends_on": ["other-step"],
  "condition": "CEL guard expression",
  "timeout": "30s",
  "retry": { "max": 3, "backoff": "exponential", "delay": "1s", "max_delay": "30s" },
  "on_error": { "strategy": "ignore | fail_workflow | fallback_step | retry", "fallback_step": "id" },
  "config": { /* type-specific */ }
}

type defaults to action. See workflow-schema.md for all config blocks.

Step Types

action (default)

Executes a registered action. Set action to the action name, params for input.

condition

Evaluates a CEL expression and branches.

json
{
  "id": "route",
  "type": "condition",
  "config": {
    "expression": "inputs.env",
    "branches": { "prod": [...], "staging": [...] },
    "default": [...]
  }
}
Show full SKILL.md (464 more words)Show less
loop

Iterates over a collection or condition. Loop variables: ${{loop.item}}, ${{loop.index}}.

json
{
  "id": "process-items",
  "type": "loop",
  "config": {
    "mode": "for_each",
    "over": "[\"a\",\"b\",\"c\"]",
    "body": [
      {
        "id": "hash",
        "action": "crypto.hash",
        "params": { "data": "${{loop.item}}" }
      }
    ],
    "max_iter": 100
  }
}

Modes: for_each (iterate over), while (loop while condition true), until (loop until condition true).

parallel

Executes branches concurrently.

json
{
  "id": "fan-out",
  "type": "parallel",
  "config": {
    "mode": "all",
    "branches": [
      [{ "id": "a", "action": "http.get", "params": {...} }],
      [{ "id": "b", "action": "http.get", "params": {...} }]
    ]
  }
}

Modes: all (wait for all branches), race (first branch wins).

wait

Delays execution or waits for a named signal.

json
{ "id": "pause", "type": "wait", "config": { "duration": "5s" } }
reasoning

Suspends workflow for agent decision. Empty options = free-form (any choice accepted).

json
{
  "id": "review",
  "type": "reasoning",
  "config": {
    "prompt_context": "Review data and decide",
    "options": [
      { "id": "approve", "description": "Proceed" },
      { "id": "reject", "description": "Stop" }
    ],
    "data_inject": { "analysis": "steps.analyze.output" },
    "timeout": "1h",
    "fallback": "reject",
    "target_agent": ""
  }
}

Variable Interpolation

Syntax: ${{namespace.path}}

NamespaceExampleAvailable fields
steps${{steps.fetch.output.body}}<id>.output.*, <id>.status
inputs${{inputs.api_key}}Keys from params in opcode.run
workflow${{workflow.run_id}}run_id, name, template_name, template_version, agent_id
context${{context.intent}}Keys from context in workflow definition
secrets${{secrets.DB_PASS}}Keys stored in vault
loop${{loop.item}}, ${{loop.index}}item (current element), index (0-based)

Two-pass resolution: non-secrets first, then secrets via AES-256-GCM vault.

CEL gotcha: loop is a reserved word in CEL. Use iter.item / iter.index in CEL expressions. The ${{loop.item}} interpolation syntax is unaffected.

See expressions.md for CEL, GoJQ, Expr engine details.

Built-in Actions

CategoryActions
HTTPhttp.request, http.get, http.post
Filesystemfs.read, fs.write, fs.append, fs.delete, fs.list, fs.stat, fs.copy, fs.move
Shellshell.exec
Cryptocrypto.hash, crypto.hmac, crypto.uuid
Assertassert.equals, assert.contains, assert.matches, assert.schema
Expressionexpr.eval
Workflowworkflow.run, workflow.emit, workflow.context, workflow.fail, workflow.log, workflow.notify

Quick reference (most-used actions):

  • http.get: url (req), headers, timeout, fail_on_error_status -- output: { status_code, headers, body, duration_ms }

  • shell.exec: command (req), args, stdin, timeout, env, workdir -- output: { stdout, stderr, exit_code, killed }

  • fs.read: path (req), encoding -- output: { path, content, encoding, size }

  • workflow.notify: message (req), data -- output: { notified: true/false } -- pushes real-time notification to agent via MCP SSE (best-effort)

  • expr.eval: expression (req), data -- output: { result: <value> } -- evaluates Expr expression against workflow scope (steps, inputs, workflow, context)

See actions.md for full parameter specs of all 26 actions.

Scripting with shell.exec

shell.exec auto-parses JSON stdout. Convention: stdin=JSON, stdout=JSON, stderr=errors, non-zero exit=failure. Use stdout_raw for unprocessed text.

See patterns.md for language-specific templates (Bash, Python, Node, Go).

Reasoning Node Lifecycle

  1. Workflow reaches a reasoning step

  2. Executor creates PendingDecision, emits decision_requested event

  3. Workflow status becomes suspended

  4. Agent calls opcode.status to see pending decision with context and options

  5. Agent resolves via opcode.signal:

    json
    {
      "workflow_id": "...",
      "signal_type": "decision",
      "step_id": "reason-step",
      "payload": { "choice": "approve" }
    }
  6. Workflow auto-resumes after signal

  7. If timeout expires: fallback option auto-selected, or step fails if no fallback

Common Patterns

See patterns.md for full JSON examples: linear pipeline, conditional branching, for-each loop, parallel fan-out, human-in-the-loop, error recovery, sub-workflows, and MCP lifecycle.

Error Handling

StrategyBehavior
ignoreStep skipped, workflow continues
fail_workflowEntire workflow fails
fallback_stepExecute fallback step
retryDefer to retry policy

Backoff: none, linear, exponential, constant. Non-retryable errors (validation, permission, assertion) are never retried.

See error-handling.md for circuit breakers, timeout interactions, error codes.

Performance

10-step parallel workflows complete in ~50µs, 500-step in ~2.4ms. The event store sustains ~15k appends/sec with <12% drop under 100 concurrent writers. Worker pool overhead is ~0.85µs/task (>1M tasks/sec at any pool size).

Full benchmark charts, per-scenario breakdowns, and methodology: docs/benchmarks.md.

© LeoYeAI, 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 7 other files (references) in skills/opcode of LeoYeAI/openclaw-master-skills.

  • SKILL.md
  • _meta.json
  • references/actions.md
  • references/error-handling.md
  • references/expressions.md
  • references/operations.md
  • references/patterns.md
  • references/workflow-schema.md

Open the folder on GitHubat commit e5199b5

Compare with similar skills

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

Opcode compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Opcode this skillLeoYeAI/openclaw-master-skills2.2k—~4.8kAutomated safety check: PassMIT
Ask User QuestionMemTensor/MemOS12k—~1kAutomated safety check: PassApache-2.0
Agent Self-Customizationnanocoai/nanoclaw31k1 repos~1.5kAutomated safety check: NotesMIT
Linggenlinggen/linggen-memory109—~8.6kAutomated safety check: NotesMIT-0
Fewer Permission Promptsasgeirtj/system_prompts_leaks69k—~1.9kAutomated safety check: PassCC0-1.0
Dutis macOS Handler Managertsonglew/dutis251—~1.2kAutomated safety check: PassNone

Similar skills

  • Ask User Question

    MemTensor/MemOS

    Shows a question as a modal in the interface to clarify a task, collect a preference or get approval, since the user cannot see terminal output.

    12k GitHub stars~1k tokensUpdated 8 days ago
    Agent WorkflowsAuto-check passed
  • Agent Self-Customization

    nanocoai/nanoclaw

    A decision tree for an agent changing its own setup: edit memory directly, request approval for packages and MCP servers, and delegate code edits to a builder agent.

    31k GitHub starsUsed in 1 repo~1.5k tokens
    Agent WorkflowsAuto-check: notes
  • Linggen

    linggen/linggen-memory

    Linggen — durable cross-host memory plus browser control, over two local MCP servers: ling-mem for memory, the Linggen engine for browser, X and agents.

    109 GitHub stars~8.6k tokensUpdated 2 days ago
    Agent WorkflowsAuto-check: notes
  • Fewer Permission Prompts

    asgeirtj/system_prompts_leaks

    Scan your transcripts for common read-only Bash and MCP tool calls, then add a prioritized allowlist to project .claude/settings.json to reduce permission prompts.

    69k GitHub stars~1.9k tokensUpdated yesterday
    Agent WorkflowsAuto-check passed
  • Inspects, plans, changes and rolls back macOS default app handlers for file types, MIME types and URL schemes through Dutis, with approval before any write.

    251 GitHub stars~1.2k tokensUpdated 2 days ago
    Productivity & AutomationAuto-check passed
  • Dive Into LangGraph

    luochang212/dive-into-langgraph

    A Chinese-language guide and reference for building agents with LangGraph 1.0, from a first ReAct agent through middleware, memory, MCP, RAG and web search.

    457 GitHub stars~837 tokensUpdated 26 days ago
    AI & LLM EngineeringAuto-check: notes

More from LeoYeAI/openclaw-master-skills

All 1,215 skills in this repo
  • DevOps Pipeline Management

    LeoYeAI/openclaw-master-skills

    Manages pipelines on a DevOps quality and efficiency platform through its OpenAPI: list workspaces and templates, create, update, run and cancel pipelines, and read run records.

    2.2k GitHub stars~4.2k tokensUpdated 2 mo ago
    Auto-check: notes
  • Feishu Document Collaboration

    LeoYeAI/openclaw-master-skills

    Patches OpenClaw's Feishu extension so an edited document triggers an isolated agent session that reads the doc and replies inline, turning it into a live chat space.

    2.2k GitHub stars~2k tokensUpdated 2 mo ago
    Auto-check passed
  • Files Memory System

    LeoYeAI/openclaw-master-skills

    Multi-context memory management system for OpenClaw agents with group-isolated storage, global shared memory, workspace organization, and group-specific skills isolation.

    2.2k GitHub stars~3.8k tokensUpdated 2 mo ago
    Auto-check passed
  • GEO-Claw AI Visibility Agent

    LeoYeAI/openclaw-master-skills

    Runs a brand's AI-search visibility work end to end: diagnosing how AI platforms represent it, repositioning it, producing AI-optimized content and monitoring ongoing mentions.

    2.2k GitHub stars~4.7k tokensUpdated 2 mo ago
    Auto-check passed
  • Google Workspace CLI

    LeoYeAI/openclaw-master-skills

    Installs and authenticates the gws CLI, then automates Gmail, Drive, Sheets, Calendar, Docs, Chat and Tasks with ready-made recipes, persona bundles and security audits.

    2.2k GitHub stars~2.6k tokensUpdated 2 mo ago
    Auto-check: notes
  • HealthFit Health Advisors

    LeoYeAI/openclaw-master-skills

    Runs four advisor roles, a fitness coach, nutritionist, data analyst and TCM practitioner, to build a health profile and track workouts, diet and wellness over time.

    2.2k GitHub stars~4.4k tokensUpdated 2 mo ago
    Auto-check passed

Categories

Questions about Opcode

What does Opcode do?

Zero-token execution layer for AI agents. An agent skill from LeoYeAI/openclaw-master-skills. Opcode is an agent skill from LeoYeAI/openclaw-master-skills. Zero-token execution layer for AI agents.

When should I use Opcode?

Opcode fits situations like: defining workflows; running templates; checking status; sending signals.

How do I install Opcode in Claude Code?

Run `npx skills add LeoYeAI/openclaw-master-skills --skill opcode -a claude-code`. Or copy the skill folder (skills/opcode in LeoYeAI/openclaw-master-skills) into .claude/skills/opcode in your project. Claude Code loads it when a task matches its description.

How do I install Opcode in Codex?

Run `npx skills add LeoYeAI/openclaw-master-skills --skill opcode -a codex`. Or copy the skill folder (skills/opcode in LeoYeAI/openclaw-master-skills) into .agents/skills/opcode in your project. Codex loads it when a task matches its description.

Can I use Opcode 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 LeoYeAI/openclaw-master-skills --skill opcode -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/opcode, .gemini/skills/opcode, .github/skills/opcode and .opencode/skills/opcode in your project.

What does Opcode need to run?

Going by SKILL.md and its folder, Opcode needs the command-line tools its instructions call (go) and credentials named OPCODE_VAULT_KEY. Our summary lists: A credential in OPCODE_VAULT_KEY. Compatibility (from SKILL.md): Requires Go 1.25+, CGO_ENABLED=1, and gcc or clang. Runs as SSE daemon on macOS and Linux. Linux: cgroups v2 for process isolation. macOS: timeout-only fallback. .

Does Opcode access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Opcode 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 Opcode use?

Opcode 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 Opcode use?

About 4.8k tokens (SKILL.md is roughly 19k 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 14k tokens, read only when the agent opens those files.

What are the alternatives to Opcode?

Skills that share tags, products or a category with Opcode: Ask User Question (MemTensor/MemOS, 12k stars), Agent Self-Customization (nanocoai/nanoclaw, 31k stars), Linggen (linggen/linggen-memory, 109 stars) and Fewer Permission Prompts (asgeirtj/system_prompts_leaks, 69k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Opcode?

LeoYeAI (a GitHub user) maintains it in LeoYeAI/openclaw-master-skills, which has 2,158 GitHub stars. The repository holds 1,215 skills in this directory. The repository was last updated on July 20, 2026.

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