yield/
FREE · OPEN SOURCE · DEVELOPER PREVIEW
Evals →Docs →SDKs · latest published releases

For programmers using coding agent skills

Keep your skills. Run the workflow in code.

Package skills however you like. Yield runs the repeatable workflow behind them—with steps, checks, approvals, and saved state in code.

See it work ↓ Read the docs → View source ↗ Install Yield ↓
live skill workflow / code reviewready
TSgenerated adapter →skills/review/main.ts
import { defineSkill } from "@operatorstack/yield";
type Review = { critical: number; fixed: number };
 
defineSkill((ctx) => {
  // Run a deterministic check before asking for judgment.
  const check = ctx.runCommand("typecheck", "npm run typecheck", 300);
  ctx.require(check.exit_code === 0, "typecheck passes", check);
 
  // Ask the coding agent for schema-checked JSON about risks the typecheck cannot decide.
  const review = ctx.agentTask<Review>(
    "review", "Review this branch for critical risks.",
    { stdout: check.stdout }, reviewSchema,
  );
  // Keep the release rule in code, not in the prompt.
  ctx.require(review.critical === 0, "no critical findings", review);
  // Save the structured review as the run result.
  return review;
});

Code runs the check. The coding agent returns a typed review. Code applies the gate.

Check → typed review → require → save the result.

Skill

One reusable capability.

Workflow

Order, branches, checks, and saved state.

Skill workflow

An executable composition of skills, code, commands, and human input.

Adapter

Lets a coding agent discover and start it.

First-party result · August 9, 2026

40/40

Owned workflow tests finished across every supported SDK. Open the evidence →

Yield ran the exact workflow steps.

Ten workflows passed in TypeScript, Python, Go, and Rust. Eight runtime checks also passed for responses, replay, choices, changed code, and failed rules.

10 × 4workflow patterns × SDKs
8 / 8runtime checks passed
CLAIMWhat this proves—and what it does not →

00 / BEFORE + AFTER

Keep the helpful words. Move the repeatable steps.

Use words for the goal, context, and examples. Use code for rules that must run the same way each time.

Beforeone skill full of rules
MDSKILL.mdinstructions
# Incident repair

- Always inspect the incident first.
- Retry when the evidence is weak.
- Before a repair, ask a person.
- After a repair, verify the result.
- Complete only if verification passes.
- Stop after three attempts without a confirmed cause.
Afterthe same steps in code
TSincident-repair.tsskill workflow
import { defineSkill } from "@operatorstack/yield"

defineSkill((ctx) => {
  for (let attempt = 0; attempt < 3; attempt++) {
    const id = `attempt-${attempt}`
    const report = ctx.agentTask<Record<string, unknown>>(
      `${id}-inspect`, "Inspect the incident."
    )
    if (Object.keys(report).length === 0) continue

    const approved = ctx.askUser(
      `${id}-approve`, "Apply the repair? Reply yes or no."
    )
    if (approved !== "yes") ctx.refused("repair not approved")

    const repair = ctx.runCommand(`${id}-repair`, "./scripts/repair.sh", 300)
    ctx.require(repair.exit_code === 0, "repair succeeds", repair)
    const verify = ctx.runCommand(`${id}-verify`, "./scripts/verify.sh", 300)
    ctx.require(verify.exit_code === 0, "verification passes", verify)
    return { evidence: report }
  }
  ctx.blocked("confirmed evidence is missing")
})
SKILL.md

Explain the goal. Run the program. Return its saved result.

Use a language you know

Write Go, TypeScript, Python, or Rust.

Test before you run

Review changes and test every path.

Pick up where you left off

The saved run survives a new session.

Stop when you should

If proof is missing, Yield saves the reason and stops.

01 / WHAT HAPPENS

The agent does the work. Yield remembers the workflow.

Start a small program. It runs one step, saves the result, and knows what comes next—even in a new session.

001

You run your custom command

Your command starts your workflow file.

002

The agent works

Your workflow can call the agent, run commands, or ask a person.

003

Every agent finds it

Yield writes a small adapter in each agent's project directory. The workflow stays in one place.

USE BOTH

Not a replacement for your skills.

One canonical workflowKeep the logic, checks, dependencies, and saved state under skills/.

Generated agent adaptersLet Cursor, Codex, Claude Code, and registry-supported hosts discover it.

02 / SKILL WORKFLOW LIBRARY

Use the language you already know.

These are skill workflows you write. Yield provides the primitives to ask, run commands, require proof, and save the result.

GOinvestigate.go

03 / START

Start with the runtime.

Install Yield, then create, test, register, and run one workflow by hand.Manual quickstart →

TypeScript

Install the SDK and repository-local CLI.

Run in the repository
npm install --save-exact @operatorstack/yield

@operatorstack/yield · npm ↗

Python

Install the SDK and module launcher.

Run in the repository
python -m pip install yieldskill

yieldskill · PyPI ↗

Go

Install the CLI under the repository.

Run in the repository
mkdir -p .yield/bin
GOBIN="$PWD/.yield/bin" go install github.com/operatorstack/yield/cmd/yskill@latest

Go reference · pkg.go.dev ↗

Rust

Install the CLI under the repository.

Run in the repository
cargo install yieldskill --root .yield --locked

yieldskill · crates.io ↗

Package installation creates no skill or coding-agent adapter. Learn the manual workflow first; then install the optional developer helper →

04 / START HERE

Start with work that already has rules.

Use Yield when your instructions say what must happen first, what can retry, or when a person must approve.

  1. GOFind the cause of a buginspect → test an idea → retry up to the limit → finish or stop
  2. TSRelease with approvalrun checks → ask a person → release or stop
  3. PYCheck and fix a setupcheck → suggest a fix → repair → check again
  4. RSRun a safe data changepreview → review → approve → apply → verify
  5. IDEAImprove a skill within a fixed budgetpropose → test → compare → accept or reject → stop when proof is missing

05 / BUILT TO STOP

A changed step never reuses the wrong answer.

Yield checks the saved run before it continues. If the program changed, the run stops and tells you.

  1. PASSOne clear next stepThe program returns one request or one final result. Then it exits.
  2. PASSEvery run says how it endedThe run records finished, blocked, or refused.
  3. STOPOld answers stay with old stepsIf a step changes, Yield stops before it uses the saved answer.
  4. TRACESee why the run stoppedInspect the step, result, and failed requirement.

06 / NO MAGIC CLAIMS

Clear limits. Useful guarantees.

Yield keeps the steps in order. It does not make every model answer true.

WHAT YIELD KNOWS

A valid answer can still be wrong

Yield can check the format. Your workflow must still check the facts.

Yield sees its own steps

It cannot see every action an agent takes outside the run.

Command results are saved directly

Yield runs the command and records what happened.

07 / TRY ONE

Start with one skill that has too many rules.

Keep the useful instructions. Move only the repeatable steps. You do not need a new agent platform.

  1. 001Find a skill with repeated rulesLook for words such as always, retry, before, after, or stop when.
  2. 002Keep the helpful guidanceLeave the goal, examples, and tool notes in SKILL.md.
  3. 003Move the strict stepsPut order, retries, approvals, saved state, and finish rules in Yield.
  4. 004Try every pathTest the happy path, the stop path, and each choice before an agent runs it.