yield/
FREE · OPEN SOURCE · EARLY LAB
SDKs · v0.1.8

For skills that have outgrown a checklist

Keep the instructions. Move the steps to code.

Yield turns long agent instructions into small programs you can run, test, pause, and resume.

See it work ↓ View source ↗ Install an SDK ↓
HOSTED BY OPERATORSTACK · NO PACKAGE-REGISTRY ACCOUNT NEEDED
$ npm install @operatorstack/yield
live example / code reviewready
check := yield.RunCommand("npm run typecheck")
review := yield.AgentTask("review this branch")
yield.Require(check.OK && review.Critical == 0)
yield.Complete(review)

Example workflow inspired by gstack’s review process ↗. Yield controls the gates; the agent performs the review.

Compile → review → require proof → save the result.

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
ALWAYS inspect the incident first.
RETRY when the evidence is weak.
BEFORE a repair, ask a human.
AFTER a repair, verify the result.
Complete ONLY IF verification passes.
STOP WHEN three attempts have no confirmed cause.
Afterthe same steps in code
for attempt := 0; attempt < 3; attempt++ {
  report := yield.AgentTask("inspect incident")
  if report.Confirmed {
    approved := yield.AskUser("Apply repair?")
    yield.Require(approved)
    verified := yield.RunCommand("verify repair")
    yield.Require(verified.OK)
    yield.Complete(report.Evidence)
  }
}
yield.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 / COME BACK LATER

Close the window. Start a new session. Keep your place.

Yield saves each answer. When you return, it reads the finished steps and asks for the next one.

001

Start again

Run the same small program.

002

Read saved answers

Skip work the run already finished.

003

Ask for one next step

Stop at the first question with no answer.

004

Continue any time

Save the answer and carry on later.

02 / WHO DOES WHAT

Let the model think. Let code keep the order.

The model still writes, compares, and decides. Your program decides what happens first, when to ask a person, and when the work is done.

ONE CLEAR OWNER ↓

AskUser

A person answers

Ask for a choice, a missing fact, or approval.

AgentTask

The model thinks

Ask the model to inspect, compare, explain, or propose.

RunCommand

Yield runs it

Run a command and save the real output.

Require

Your code checks

Continue only when the required proof exists.

Complete · Blocked · Refused

The run ends

Finish, stop with a reason, or record that someone said no.

03 / USE BOTH

Keep the useful words. Move the strict rules.

SKILL.md explains the work. Yield runs the steps that must stay in order.

ONE SKILL · TWO JOBS ↓

01 · SKILL.md

Explain the workShare the goal, context, examples, and tools. Start with a file that works across agents.

What gets hardAs the file grows, the model must read and follow every rule again.

WORKS WITH ↓The short skill tells the agent how to start the Yield program.

02 · YIELD

Run the stepsPut order, retries, choices, approvals, saved state, and finish rules in code.

What you maintainYield adds a small program. Keep it in sync with the skill and test it like other code.

SKILL.md explains the job. Yield keeps the steps on track.

04 / YOUR LANGUAGE

Use the language you already know.

Write the program in Go, TypeScript, Python, or Rust. Yield runs each one the same way.

05 / INSTALL

Add Yield in the language you use.

The SDKs are open source and served from OperatorStack's package service. Pick one command and start with one workflow.

TypeScript

Install the scoped package through the read-only registry front door.

npm install @operatorstack/yield \ --registry=https://get.operatorstack.systems/npm/

@operatorstack/yield · 0.1.8

Python

Use the OperatorStack Python index for this install.

python -m pip install yieldskill \ --index-url https://get.operatorstack.systems/pip/simple/

yieldskill · 0.1.8 · Python 3.10+

Go

Point this command at the OperatorStack Go module proxy.

GOPROXY=https://get.operatorstack.systems/go,direct \ go get github.com/operatorstack/yield@v0.1.8

github.com/operatorstack/yield · v0.1.8

Rust

Add the read-only sparse registry once, then add the crate.

# .cargo/config.toml [registries.operatorstack] index = "sparse+https://get.operatorstack.systems/cargo/index/" cargo add yieldskill --registry operatorstack

yieldskill · 0.1.8 · Rust 2021

06 / 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

07 / 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. DETAILThe technical trace stays availableop_drifts → consume_unchecked → CONSUMED_MISMATCHED

08 / 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.

09 / 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.