Where evoke is going, as a film.

Title

Software, by reflex. A film about where evoke is going.

One reflex

It starts with one reflex: a small program someone wrote, and a manifest anyone can read.

Its inputs come from a list, a word you taught it, or a piece of what you typed. Nothing is made up.

It runs on its own only when evoke is sure enough: 0.6 to look something up, 0.8 to change something.

A step that can't be undone asks a person, however sure evoke is.

A sentence lights a plan

You type one sentence.

evoke reads it against every reflex you installed. The ones it needs light up as a plan, before anything runs.

Lookups fire together. Changes wait their turn. The rollback stops and asks.

Seven small programs in one plan, and you saw all of it before anything ran.

Plans people can hold

A plan becomes something you can keep: saved, reviewed, and run again by someone else.

Later, a short sentence brings back the whole reviewed plan.

Closing the month takes a second person before the books change.

A step can wait for its person, overnight if it has to.

When they answer, the plan picks up where it stopped. Nothing that ran runs twice.

Six problems

The same shape answers real problems.

An outage. Three lookups at once, a suspect found, a rollback that asks, two posts in turn.

A stolen laptop. Three lookups at once, four changes in turn with the wipe asking first, then a post.

A late shipment. Three lookups at once, the shortfall, then a reserve and a purchase that asks first.

Closing the month. Four lookups at once, a reconciliation, a second person, then the report sent.

A cancelled flight. Three lookups at once, three changes in turn with the booking asking first, then everyone told.

A new colleague. Two lookups at once, two changes in turn with the order asking first, then a first day booked.

Across machines

Real work lives on many machines: the deploys on one, the logs on another, the chat somewhere else.

Your evoke decides the plan. Each step runs where its program, its keys and its person live.

Every call is signed, and each machine checks it against its own rules.

The machine asked its own person, even after Dana said yes. It ran once and signed a receipt.

The machine asked its own person, who declined. Nothing ran, and nothing after it.

Decide here, run there, sign everything.

Receipts, and who sees what

Each machine answers with a signed receipt: what ran, which version, who said yes, and when.

Each side sees only what it needs. deploy.acme sees its own step's words, never the whole sentence.

Its on-call sees the call it is asked about, and as much of the plan as Dana chose to share.

The makers of evoke see nothing. Nothing we run sits between you and your machines.

Everywhere people act

People will ask from wherever they are. In a chat, the plan is posted and each gate is answered by its own person.

By voice, the sentence changes place. The plan and its rules stay the same.

An application ships its reflexes the way it ships a package.

An agent can propose a sentence. evoke decides, and the confirm goes to a person, never back to the model.

A galaxy with no center

Each team and each company publishes its reflexes, and you connect the ones you trust.

Plans cross between them directly. Nothing in the middle routes, stores or approves. Not even us.

A network of small programs that fires the way a trained reflex does: at once where it is sure, and stopping where it must.

The road

The first step runs today.

The rest is built in order, and each step is measured before the next one is promised.

The last word

People write the programs. A sentence picks the plan. A person signs what can't be undone.