Run the clear requests. Hold the rest for a person.

One line ran, one waits, one fits nothing.

A file of three requests, decided against the ops example's three reflexes. Recorded on 21 September 2026 against Jev, TypeSafe AI's model, which reads each sentence.

An app of eleven lines decides each request.

The app reads a line, decides, and runs only what is settled. The reflexes are the three from the ops example, in the same project directory.

scale checkout to 6 in staging
silence db-3
what is the weather like

// The inbox as a stream. What is sure runs; the rest is queued for a person,
// with the ranking or the missing pieces.
import { createInterface } from "node:readline"
import { load } from "@evoke-build/evoke"

const ops = await load({ root: import.meta.dirname })
for await (const line of createInterface({ input: process.stdin })) {
  const d = await ops.decide(line)
  if (d.outcome === "run") console.log((await ops.run(d)).text)
  else console.log(`queued · ${d.outcome} · "${line}"`)
}

With no terminal, a question becomes an exit code.

The evoke command reads the same file, one request per line. With no terminal attached, as in a cron job, evoke cannot ask. A line that needs an answer prints the command to run yourself, and the run ends with exit code 3.

$ evoke < inbox.txt
  scale service="checkout" env="staging" replicas="6"  0.90
deployment.apps/checkout-api scaled
  an ask needs a terminal  →  evoke "silence db-3"
  none 1.00 · 3 more under 0.01
[3]

Feed a file of requests to the scale reflex.

This uses the project from the ops example, with its scale reflex and your words. The first request scales a real deployment, so point your words at one you may change.

• The ops projectThe ops example's Set it up builds it: the reflex, your words and your key.
• kubectl, with accessThe first request scales a deployment, for real.
• A classifier keyOne request per line, billed by the provider to your key. The evoke command answers a line you repeat from a local cache.
• Your queueThe app prints what it would queue. Yours would store each decision and show it to someone.

1. Write the requests

   Save three requests in ~/ops/inbox.txt, one per line: one that names everything, one that leaves out the environment, and one that fits no reflex.

   ~/ops/inbox.txtyours

   scale checkout to 6 in staging
   scale checkout to 3
   what is the weather like

2. Try the file

   Each line is decided, and nothing runs. The first would run, the second asks for its environment, and the third fits nothing.

   evoke try < inbox.txtCopy

3. Run it at your terminal

   The first line scales for real. evoke asks at your terminal for the environment the second line lacks: answer only if that scale may run, or press Ctrl-D to decline. The third line prints its ranking.

   evoke < inbox.txtCopy

4. Or run it unattended, and keep every decision

   Where no terminal is attached, such as a cron job or CI, each request becomes one JSON line: what ran and its result, what is missing, or the ranking. The first line scales here too, and the run ends with exit code 3. A person works from the file.

   evoke --json < inbox.txt > decided.jsonlCopy

Put your own requests in inbox.txt. Each one is decided against the reflexes in the project, so add yours with evoke add ./<name>.

The same file, from a Node application.

queue.ts loads ~/ops and decides each line. It runs only what is settled, and queues the rest. It needs Node 24.5 or newer, and ES modules.