Skip to content
Skills Library
AI & agents · Automation

step

/step

Run ONE prompt once and capture its structured output — the single LLM/work unit between /agentflow:reduce (one agent over N inputs) and /agentflow:foreach (one agent per item). Pick where it runs with `--runtime`: `main` (inline), `subagent` (one Agent), or sessionless CLIs `claude-cli` (`claude -p`) / `codex-cli` (`codex exec`) that the engine executes itself. This is how a workflow step can be an arbitrary skill, an MCP-using agent, `claude -p`, or a different model (e.g. cross-model). USE for a single ad-hoc step: "run this one prompt", "ask codex to …", "have a second model review this",

Repository
agentflow ↗
Licence
Apache-2.0
Last repository change
24.07.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 24.07.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Run ONE prompt once and capture its structured output — the single LLM/work unit between /agentflow:reduce (one agent over N inputs) and /agentflow:foreach (one agent per item). Pick where it runs with `--runtime`: `main` (inline), `subagent` (one Agent), or sessionless CLIs `claude-cli` (`claude -p`) / `codex-cli` (`codex exec`) that the engine executes itself. This is how a workflow step can be an arbitrary skill, an MCP-using agent, `claude -p`, or a different model (e.g. cross-model). USE for a single ad-hoc step: "run this one prompt", "ask codex to …", "have a second model review this",

Triggers from the description

run this one promptask codex to …have a second model review this

Arguments

/step --prompt "<text>" [--prompt-file <path>] --runtime main|subagent|claude-cli|codex-cli [--model …] [--subagent-type <name
Original author description

Run ONE prompt once and capture its structured output — the single LLM/work unit between /agentflow:reduce (one agent over N inputs) and /agentflow:foreach (one agent per item). Pick where it runs with `--runtime`: `main` (inline), `subagent` (one Agent), or sessionless CLIs `claude-cli` (`claude -p`) / `codex-cli` (`codex exec`) that the engine executes itself. This is how a workflow step can be an arbitrary skill, an MCP-using agent, `claude -p`, or a different model (e.g. cross-model). USE for a single ad-hoc step: "run this one prompt", "ask codex to …", "have a second model review this",

How it works

  1. 1. Init
  2. 2. Execute — branch on config.runtime
  3. 3. Result
  4. In a workflow (WORKFLOW.md)
Original SKILL.md headings · 52 lines, 284 words
SKILL.md preview
---
name: step
user-invocable: false
description: |
  Run ONE prompt once and capture its structured output — the single LLM/work unit between
  /agentflow:reduce (one agent over N inputs) and /agentflow:foreach (one agent per item). Pick where it
  runs with `--runtime`: `main` (inline), `subagent` (one Agent), or sessionless CLIs `claude-cli`
  (`claude -p`) / `codex-cli` (`codex exec`) that the engine executes itself. This is how a workflow step
  can be an arbitrary skill, an MCP-using agent, `claude -p`, or a different model (e.g. cross-model).

  USE for a single ad-hoc step: "run this one prompt", "ask codex to …", "have a second model review
  this", "do this one thing and capture the result". For per-item work use /agentflow:foreach; to
  synthesize many inputs use /agentflow:reduce.
allowed-tools: Bash, Read, Write, Edit, Agent
argument-hint: --prompt "<text>" [--prompt-file <path>] --runtime main|subagent|claude-cli|codex-cli [--model …] [--subagent-type <name>] [--input <file>]
---

# /agentflow:step

> **Make it visible:** say in one line that you're running a step (id + runtime).

## 1. Init

```bash
node "${CLAUDE_PLUGIN_ROOT}/dist/state/step.js" init <id> \
  (--prompt "<text>" | --prompt-file <path>) --runtime <main|subagent|claude-cli|codex-cli> \
  [--model <…>] [--subagent-type <name>] [--input <file>] [--force]
```

## 2. Execute — branch on `config.runtime`

- **`claude-cli` / `codex-cli`** — the **engine runs it** sessionlessly; you don't dispatch anything:
  ```bash
  node "${CLAUDE_PLUGIN_ROOT}/dist/state/step.js" run <id>
  ```
  It spawns `claude -p <prompt> --output-format json` (or `codex exec <prompt> --json`), captures the
  result, and marks the run done/failed. Binaries must be installed + logged in; override with
  `$STEP_CLAUDE_BIN` / `$STEP_CODEX_BIN`. (Validate the exact flags against your installed CLIs.)
- **`subagent`** — dispatch **one** `Agent` (`subagent_type` + `model` from config) with the step's
  prompt (and `--input` file if any); tell it to return the result. Then record it:
  ```bash
  node "${CLAUDE_PLUGIN_ROOT}/dist/state/step.js" complete <id> --output "<agent result>"
  # or, if the agent wrote a file: ... complete <id> --output-path <file>
  ```
- **`main`** — do the work inline in this thread, then `complete <id> --output "<result>"`.

On failure: `node "${CLAUDE_PLUGIN_ROOT}/dist/state/step.js" fail <id> --error "…"`.

## 3. Result

`status <id>` reports `output_pointer` — a file holding the step's output, consumable by a later stage
(`{{stages.<name>.result_pointer}}` in a workflow) or a `/agentflow:reduce`.

## In a workflow (WORKFLOW.md)

A `## name · step` stage runs a step; bullets become flags:

```markdown
## critique · step
- runtime: claude-cli
- model: opus
- prompt: Critique the draft at {{stages.draft.result_pointer}}; list concrete weaknesses.
```

Two `step` stages with different `--model` inside a `repeat`/`until` loop give you a **cross-model
conversation** (model A proposes, model B critiques) — adversarial or cooperative — with the loop
predicate as the deterministic convergence check.

Versions

The database has no other skills named step.

Database snapshot: 13.11.2026 · package version c05ff9c76e81 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100codex-exec
    Run one prompt through headless Codex and capture the result. Use when: wanting a one-shot `codex exec` run or CI step. Not for batches or retries.
  • 100pipe
    Run an ordered pipeline of stages — each a bash command, a json write, or another primitive (/agentflow:enumerate, /agentflow:foreach, /agentflow:group, /agentflow:reduce, or a loop). The composer: it holds no map/fold/loop of its own; it sequences the primitives that do, with…
  • 100create-workflow
    Author a reusable workflow-file by composing the Agent Flow primitives (enumerate, foreach, group, reduce, iterate) and bash/json stages into a declarative JSON `WorkflowSpec`, then validate it — ready to run with `/agentflow:run-workflow`. The builder counterpart to…
  • 95codex-exec
    Run OpenAI Codex CLI non-interactively to execute tasks, generate code, or get a second opinion. Use this skill whenever the user says "run codex", "ask codex", "codex exec", "have codex do", "send to codex", "pipe to codex", or wants to delegate a task to Codex for a second…
  • 100codex
    Use when you need to run OpenAI Codex CLI from another agent (Claude Code or any shell-capable agent): hand it a task with `codex exec`, run several Codex workers in parallel, continue a Codex session with `codex exec resume`, run `codex exec review`, capture its final report,…
  • 100codex
    Use the local Codex CLI as an independent second agent. Two branches — (1) proactively run `codex review` for a second opinion after completing a substantive change, before presenting it as done or committing; (2) delegate a well-defined implementation task via `codex exec`,…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.