One sentence looks up an address and passes it to the next step.

A value passes, a step is declined, a sentence is refused.

evoke splits your sentence into steps, in the order your words give. A classifier reads each step on its own: Jev, TypeSafe AI's model. evoke prints the plan, one line per step, before anything runs. Recorded on 26 September 2026, on a Mac.

contact is the reflex part 05 shows you how to write, over your list of people. mail, trash and lock are the collection's. The draft opened in the Mac's mail app, and nothing was sent. How the address passes ↓

The address passes because both reflexes declare the same kind.

Each reflex has a manifest, its reflex.toml, which says what it does and what it takes. contact's manifest also declares what its result holds. When that result and mail's input are of the same kind, evoke plans the pass and shows it before anything runs.

reflex = 1

description = """
Look up a person's email address in your list of people.
One person at a time; prints the address."""

not_for = ["writing to anyone", "phone numbers", "adding a person to the list"]
tags    = ["people"]
effect  = "read"
confirm = "Look up {name}'s address?"
run     = "contact.mts"

[args.name]
ask   = "Whose address?"
vocab = "people"

[yields]
email = "email"

[examples]
"look up dana's address"    = {}
"what is sam's email"       = {}
"find the address for dana" = {}

[tests]
"dana's email please" = {}
"email dana"          = false

import type { Reflex } from "./reflex.d.ts"

export default (async ({ name }) => {
  // name is the word's value: the address you stored for that person.
  if (!name.includes("@")) throw new Error(`no address for ${name}`)
  return { text: `found ${name}`, data: { email: name } }
}) satisfies Reflex

dana = { what = "Dana Ortiz, operations.", value = "dana@example.com" }
sam = { what = "Sam Lee, sales.", value = "sam@example.com" }

reflex = 1

description = """
Start an email to an address in your mail app.
A subject goes in quotes, "like this"; nothing is sent until you press send."""

not_for = [
  "checking or searching the inbox",
  "replying to or forwarding an email",
  "sending a text or a chat message",
  "opening your webmail in the browser",
  "jotting down a note",
]
tags = ["mail"]
effect = "write"
confirm = "Start an email to {to}?"
run = "mail.mts"
platforms = ["macos"]

[needs]
runs = ["open"]

[args.to]
ask  = "To which email address?"
pick = "email"

[args.subject]
ask      = "What is the subject?"
pick     = "quoted"
optional = true

[examples]
"write an email to lee@example.com"                              = { to = "lee@example.com" }
'email priya@example.com about "tuesday lunch"'                  = { to = "priya@example.com", subject = "tuesday lunch" }
'start a mail to ops@example.com with the subject "server move"' = { to = "ops@example.com", subject = "server move" }
'new mail to bob@example.com with subject "Invoice"'             = { to = "bob@example.com", subject = "Invoice" }
'write to sam@example.org, subject "Invoice 42"'                 = { to = "sam@example.org", subject = "Invoice 42" }

[tests]
"email jo@example.com"                                           = { to = "jo@example.com", subject = false }
'open a new email to billing@example.com titled "march invoice"' = { to = "billing@example.com", subject = "march invoice" }
"email my landlord"                                              = { to = false, subject = false }
"any new mail from the bank"                                     = false
"text ana that I'm running late"                                 = false
"reply to the last email from hr"                                = false

// Start an email in the default mail app: a `mailto:` URL opened, with the subject when one was given; nothing is
// sent.
import { execFile } from "node:child_process"
import { promisify } from "node:util"
import type { Reflex } from "./reflex.d.ts"

const exec = promisify(execFile)

export default (async ({ to, subject }, { signal }) => {
  if (process.platform !== "darwin") throw new Error("runs on macOS only")
  const url = subject === undefined ? `mailto:${to}` : `mailto:${to}?subject=${encodeURIComponent(subject)}`
  try {
    await exec("open", [url], { signal })
  } catch (error) {
    if (signal.aborted) throw signal.reason
    throw new Error(said(error) ?? "the mail app did not open")
  }
  return subject === undefined ? `new mail to ${to}` : `new mail to ${to} about "${subject}"`
}) satisfies Reflex

/** What a failed command said on stderr, when it said anything; else nothing, and the caller's own words stand. */
function said(error: unknown): string | undefined {
  const text = typeof error === "object" && error !== null && "stderr" in error ? error.stderr : undefined
  return typeof text === "string" && text.trim() !== "" ? text.trim() : undefined
}

test("a pronoun takes the address the step before yielded, into the ask it fills", async () => {
  const project = await load({ root: home, adapter: replay(answers) })
  const woven = await project.weave("look up dana's address and email them")
  deepStrictEqual(woven.plan.binds, [{ from: 1, to: 2, arg: "to", field: "email", kind: "email", via: "fill" }])
  equal(woven.plan.steps[1]?.decision.outcome, "ask")
  equal(woven.status, "ran")
  deepStrictEqual(woven.steps[1]?.bound, [{ arg: "to", from: 1, field: "email", value: "dana@example.com" }])
  const round = woven.steps[1]?.rounds[0]
  equal(round?.decision.outcome, "run")
  if (round?.decision.outcome !== "run") return
  equal(round.decision.call, 'mail to="dana@example.com"')
  deepStrictEqual(round.result, { text: "drafted to dana@example.com" })
  deepStrictEqual(woven.steps[0]?.rounds[0]?.result, { text: "dana <dana@example.com>", data: { email: "dana@example.com" } })
})

A reference that takes nothing asks before anything runs.

«for them» points at step 1, but a timer takes no address. evoke says so, and asks whether to run the plan as it stands. Nothing runs until you answer.

$ evoke "look up dana's address and start a 10 minute timer for them"
  1  contact name="dana"  0.98
  2  timer duration="10 minute"  1.00 · after 1
  step 2 refers to step 1, but takes nothing from it
  Run the plan as it stands?  [y]es [n]o > y
found dana@example.com
10 minutes, rings at 09:08 PM

Two reflexes you can install pass a path the same way.

download saves a file and declares the path it saved to. note takes a quoted phrase, and «it» points back. Both run wherever Node runs. Recorded on 26 September 2026 against Jev, TypeSafe AI's model, on Linux.

$ evoke "download https://evoke.build/llms.txt and note it"
  1  download url="https://evoke.build/llms.txt"  1.00
  2  note · takes path from 1
saved llms.txt to ~/Downloads (12 kB)
  2  note text="~/Downloads/llms.txt"  0.99
noted "~/Downloads/llms.txt" in ~/notes.txt

The plan for this sentence is also pinned in evoke's tests, over the whole collection, replayed from written answers. To run it yourself, install the two reflexes, name a notes file that exists, and type the sentence.

1. Install both from the collection

   evoke add evoke-build/reflexes/downloadCopy

   evoke add evoke-build/reflexes/noteCopy

2. Name the notes file

   note appends to a file that exists, so make it first.

   touch ~/notes.txt && evoke config note file "~/notes.txt"Copy

3. Type the sentence

   The plan prints first. Once the file is saved, step 2 prints again with the path, and the note is written.

   evoke "download https://evoke.build/llms.txt and note it"Copy

Set it up on a Mac, with a lookup you write.

No reflex in the collection looks up an address, so you write the lookup, and the collection's mail takes its address. The draft opens in your mail app, and you send it yourself.

• A MacThe collection's mail opens a draft in your mail app, and runs only on macOS.
• evoke and a keyInstall evoke and set your key, then come back here.
• Node 24 or newerBoth reflexes run a JavaScript file.
• gitTo install mail from the collection.

1. Make a project for your own reflexes

   A folder with an evoke.toml file is a project. When you type inside it, evoke uses only the reflexes installed there. The file's one line, adapter = "jev", has Jev, TypeSafe AI's model, read this project's sentences.

   mkdir -p ~/dev && cd ~/dev && echo 'adapter = "jev"' > evoke.tomlCopy

   A project's files decide what runs, so evoke decides in a new one only after you trust it once. It answers + trusted ~/dev.

   evoke trustCopy

2. Make the lookup reflex

   evoke new writes a working reflex from a template: a manifest, a program and its types. It prints one line for each file it wrote in contact/.

   evoke new contactCopy

3. Write its manifest

   Replace contact/reflex.toml with this manifest. Its input, name, takes a word from your list of people. effect = "read" declares that it only looks something up. The two lines under [yields] declare that its result holds an email address, and they are what lets mail take it.

   contact/reflex.tomlyours

   reflex = 1
   
   description = """
   Look up a person's email address in your list of people.
   One person at a time; prints the address."""
   
   not_for = ["writing to anyone", "phone numbers", "adding a person to the list"]
   tags    = ["people"]
   effect  = "read"
   confirm = "Look up {name}'s address?"
   run     = "contact.mts"
   
   [args.name]
   ask   = "Whose address?"
   vocab = "people"
   
   [yields]
   email = "email"
   
   [examples]
   "look up dana's address"    = {}
   "what is sam's email"       = {}
   "find the address for dana" = {}
   
   [tests]
   "dana's email please" = {}
   "email dana"          = false

4. Write its program

   Replace contact/contact.mts. Your list of people is the directory here: in step 6 you store each person's address with their word, and evoke passes that address to the program. It returns the address twice: as the line you read, and as data for the next step.

   contact/contact.mtsyours

   import type { Reflex } from "./reflex.d.ts"
   
   export default (async ({ name }) => {
     // name is the word's value: the address you stored for that person.
     if (!name.includes("@")) throw new Error(`no address for ${name}`)
     return { text: `found ${name}`, data: { email: name } }
   }) satisfies Reflex

   To use a company directory instead, look the word up there and return the same shape. Then check the reflex: evoke check reads the manifest, loads the program, and rewrites reflex.d.ts for the new input.

   cd ~/dev/contact && evoke checkCopy

5. Install both reflexes

   Back in ~/dev, add your lookup by its folder, and mail from the collection by its path. Each prints one row for the reflex it installed. contact shows as inactive until your list of people has a word.

   cd ~/dev && evoke add ./contactCopy

   evoke add evoke-build/reflexes/mailCopy

6. Add the people you write to

   Add each person with a word, a meaning and their address, in place of the ones below. The meaning is what the classifier reads. The address goes only to your program, and the classifier never sees it.

   evoke vocab people add dana "Dana Ortiz, operations." --value dana@example.comCopy

   To check the program without asking the classifier, call it by name. It prints the call, then found dana@example.com.

   evoke run contact name=danaCopy

7. Look at the plan

   evoke try runs nothing. It prints the plan first: step 1, contact for dana, then step 2, mail, which takes email from 1. Under each step come the classifier's answers for that part.

   evoke try "look up dana's address and email them"Copy

8. Type the sentence

   Type it inside ~/dev. The plan prints first, then contact prints the address. The address fills mail's to, and step 2 prints again with it. Your mail app opens a draft to Dana, and evoke prints new mail to with the address. Nothing is sent until you press send. If evoke is less sure of the email step, it shows the call and asks first.

   evoke "look up dana's address and email them"Copy

   A sentence with several steps makes one request to find its steps, then at least one for each step.

The same sentence, from a Node application.

The SDK loads ~/dev, runs the sentence with weave(), and lets your code answer its questions. It needs Node 24.5 or newer, and ES modules.

// node draft.mts "look up dana's address and email them"
import { createInterface } from "node:readline/promises"
import { load } from "@evoke-build/evoke"

const project = await load({ root: import.meta.dirname })  // ~/dev, with contact and mail
const rl = createInterface({ input: process.stdin, output: process.stdout })
const yes = async (question: string) => (await rl.question(`${question} [y/n] `)) === "y"

const woven = await project.weave(process.argv[2] ?? "", {
  confirm: d => yes(d.prompt.template),
  proceed: () => yes("Run the plan as it stands?"),
})
rl.close()
console.log(woven.status)           // "ran", or the worst step's status
console.log(woven.steps[1]?.bound)  // [{ arg: "to", from: 1, field: "email", value: "…" }]