or: curl -fsSL https://runx.ai/install | sh

```

Then choose how you want to run skills.

Docs and product engineering: build a source-bound documentation packet.

runx skill sourcey -i project=. --json

quickstart

This README has an agent-readable twin at runx.ai/SKILL.md. Give it to an agent and the agent learns the CLI, the catalog at runx.ai/x, and how to return receipts.

Install the CLI:

```bash npm i -g @runxhq/cli

Hello World

Use this package to prove the local execution and receipt path.

When a skill needs deterministic execution, typed inputs, graph stages,
authority, artifacts, or harness cases, it also carries an `X.yaml` execution
profile:

runners: default: default: true type: cli-tool command: node args: [run.mjs] inputs: message: type: string required: true ```

The split is deliberate:

- SKILL.md owns the knowledge a human and acting agent need. - X.yaml owns machine-checkable execution, authority, and evidence contracts. - package JavaScript exists only for deterministic domain computation that the graph and native capability plane cannot express cleanly. - HTTP, filesystem, process, credential, packet, and receipt mechanics belong to the runtime, not copied helpers inside skills.

Runx digest-binds the complete current manual into the acting context and the resume envelope. Declared adjacent skills contribute bounded summaries until invoked; invocation then supplies that skill's complete manual.

See Skill to Graph and Skill Catalog.

demos that prove boundaries

These checked-in paths produce receipts rather than screenshots or prose-only claims:

See Demos.

CLI path

Run a local or catalog skill directly:

runx skill <skill-ref> [runner] -i key=value --json

Seal a receipt locally in under five minutes, with no account and no hosted surface:

npm i -g @runxhq/cli
git clone --depth 1 https://github.com/runxhq/runx.git
cd runx
runx skill ./examples/hello-world -i message="hello, runx" --json

The checked-in examples/hello-world skill runs a local command, and the final --json output includes the sealed receipt (runx.receipt.v1).

business-ops is one prebuilt skill for routing a business signal end to end:

runx skill business-ops \
  -i signal="acme.com signed up 40 seats yesterday: classify the work, prepare the governed handoffs, and preserve proof" \
  --json

<picture> <source media="(prefers-color-scheme: dark)" srcset="docs/assets/ops-fanout-dark.svg"> <source media="(prefers-color-scheme: light)" srcset="docs/assets/ops-fanout-light.svg"> <img alt="one goal chaining through governed skill lanes into a sealed receipt" src="docs/assets/ops-fanout-light.svg"> </picture>

The graph is the core shape. One signal enters, skills chain under governed authority, consequential lanes hold at approval gates, and every act seals into one receipt tree that can feed the next run. The demo lanes are stand-ins; real teams bind their own context, policies, tools, providers, and readbacks.

Some other examples:

```bash