Fewer Steps

Every company is a pile of promises. A customer is promised four pumps by the eighteenth. A supplier is promised payment in thirty days. A new hire is promised a desk on Monday. Everything a company does is one of those promises on its way to being kept or broken, and the only thing that matters at the end of the year is which.

Yet almost nothing in a company’s software is about the promise. The software is about the paperwork around it: the requisition, the purchase order, the invoice, the approval, the three-way match, the month-end close. Each of those exists for one of two reasons. People cannot see everything at once, and nobody can be trusted with everything. They are workarounds for missing information and missing trust. Over a century we have mistaken them for the work.

This essay is about a different foundation. Its unit is not the document but the promise itself, carried all the way to its outcome: what was promised, who had the authority to promise it, what actually happened, and what it cost or earned. A company that runs on that record needs fewer steps. Not faster ones. Fewer.

Three things have to be true for that to work. Authority has to be explicit, so a machine can be given exactly as much of it as a person intends and not one dollar more. Outcomes have to be on the record, so judgment can be scored and taught. And a stranger, the customer or the supplier on the other side of the promise, has to be able to rely on the record without trusting anyone’s word. The rest of these pages are about how.

A powerful technology on a weak record changes nothing that matters. That sentence is the whole argument, so it is worth slowing down on.

Today’s business software is a set of documents built for people to key in. Put AI on top of it and the best you get is documents keyed in faster. The approval chain is still there. The matching is still there. The month-end close is still there. The company is the same company with a quicker typist.

Picture a controller who gets an AI assistant inside her accounting system. It drafts the purchase order in ten seconds instead of five minutes. The order then waits two days for the same three approvals. The bill is matched against it by hand next month. The close still takes a week. She saved five minutes, and nothing about the company changed, because the record it runs on did not.

It can be worse than nothing. AI makes whatever it sits on more of what it already is. On an old system, that means software acting on a person’s login, holding every authority that person has, with no record of what it used and no outcome to learn from. Faster, less visible, and no wiser.

This has happened before. In the 1890s a factory ran on one steam engine, turning a long shaft under the ceiling, with belts dropping down to every machine. When electric motors arrived, most owners did the obvious thing: they swapped the steam engine for one big electric motor and kept the shaft. Output barely moved for a generation. The gains came only when someone put a small motor on every machine and laid the floor out around the work instead of around the shaft. Whole steps disappeared. The economist Paul David told this story in 1990 to explain why computers had not yet shown up in the productivity figures. The lesson is the same now. A new source of power pays off when the layout changes, not when the old layout runs faster.

So the record has to change first. Intelligence can only act on what it can read, and a form tells it almost nothing. A promise with its authority and its outcome tells it everything. Build that record, and AI removes steps. Skip it, and you have bought the big motor and kept the shaft.

There is a second lesson in the coal and the motors, and it is less comfortable. In 1865 the economist William Stanley Jevons noticed that as steam engines became more efficient, Britain burned more coal, not less. Make something cheaper to use and people use far more of it. That is Jevons’ paradox, and it is already at work in the back office. Make a purchase order cheap to raise and a company raises more of them, and every one still needs its approvals, its match, and its place in the close. The assistant made the step cheap, and the company got more steps. Efficiency on the wrong unit multiplies the wrong thing.

Change the unit and the same law works for you. When a promise becomes nearly free to make and keep, a company makes many more of them: smaller orders from more suppliers, more customers served, more quotes, more things tried. A sixty-person pump maker can carry the supplier base and the order book of a company three times its size. That is the point, and it is also the warning. If the number of acts rises a hundredfold, nobody can approve each one, and the temptation will be to let the machine do as it likes. The only thing that lets a company take the growth without the chaos is authority that is given once, bounded, checked on every act at almost no cost, and never widened by anything but a person. Jevons tells you the volume is coming. The rest of this essay is about being ready for it.

Imagine a sixty-person company that makes industrial pumps. It runs on NetSuite, takes payment through Stripe, and does most of its real negotiating over email, like everyone else. One morning the admin presses Connect on all three. Within the hour, the owner opens a screen called Today and sees her company as it actually is: three things that need her, two bills about to be paid twice, one customer who is going to pay late, and the margin on every product she sells. Nothing has changed yet. Nothing has been written anywhere. She is just seeing it for the first time.

For a few weeks the system decides alongside the controller and scores itself. It says which bills match, which orders are at risk, which expense is a duplicate, and then watches what the controller does. At the end she reads how often it agreed with her, and where it turned out to be right when she was not. That number is hers. Nobody is asking her to trust a brochure.

Then she gives it the first piece of authority, a small one: pay matched bills under two thousand dollars. From that day those bills are paid, signed, and posted, and she sees only the ones the system is not sure about. If she ever wants it back, she revokes the grant and the work returns to her desk in a second. The owner does the same with a helper called Relay, which may order stock up to five hundred and forty dollars at a time, and not a dollar more.

A customer orders four impellers online and pays. Two are in stock and two are not, and by the afternoon a pick is planned, a work order exists, and bronze bar is on order from the foundry inside Relay’s limit, without anyone typing any of it. How that happens is Part V. When a supplier emails that a casting will be a week late, that email becomes a change to one promise, the plan re-draws itself, and one person is asked one question.

Each week, Today shows what the system learned and from whom, and which questions it has stopped needing to ask. Nobody opens NetSuite any more, though everything is still there for the accountant at year-end.

The foundry, meanwhile, received a signed order it could verify without an account, and so did the customer who bought the impellers. After a while, some of them ask to see their side of the promise too. That is the moment the record crosses the wall between two companies, and it is where the real reduction in steps begins. Most of the paperwork in any business exists at its edges, because two companies cannot trust each other’s systems. A promise both sides can rely on does not need to be entered twice, matched twice, and reconciled twice.

The system behind that Tuesday has six parts. What makes it trustworthy is less what each part does than what each one is never allowed to do.

Readers bring the world in. There is one for each kind of system a company already runs, a NetSuite reader, a Stripe reader, a mailbox reader, and each is learned once and reused by every company on that system. A reader knows how its system thinks, which is what lets a company plug in without a consultant. It never holds anyone’s private data and it never decides anything.

One grammar is what the readers write into. Every company, whatever it makes or sells, runs on the same handful of things: commitments, fulfilment, money, approvals, exceptions, outcomes. A steel mill and a dental practice differ in vocabulary, not in kind. The grammar never imposes a way of working; it reads the company’s own way out of its records.

Judgment decides what should happen next. Most of it is plain rules, because most questions in a company have plain answers once the information is in one place. For the rest there is a small, fast model that answers one typed question at a time and says how sure it is. It takes milliseconds. It never acts while unsure; below a line the company sets, it asks a person. It never writes a sentence.

Authority is the part that makes the rest safe to switch on. Every act is checked against a grant that a named person signed, for a bounded range, and the check is exact: the same inputs give the same answer every time, with a signed receipt that anyone can verify later. A model’s confidence is never mistaken for authority, and authority is never widened without a person. Revoking takes a second.

Hands write the result back, through the old system’s own door and under the same grant. They never write without one, they never treat the old system as the truth, and they never sync both ways. The old system keeps its ledger; it stops being where work happens.

Words are the last part, and the only one a language model is allowed to touch. It explains a decision, drafts the email to the foundry, listens when someone says “hold that bill”. It never decides, and it never says a number it cannot tie to a decision or a receipt.

Two kinds of model, then, and they never mix up what they are for. One judges, in types, and is taught by what happens next. The other talks.

People who have lived inside business software ask the same question at this point: where is the workflow? Who wrote “after payment, do this”? Nobody did. There is no workflow to write, because the next step is not a thing the system remembers. It is a thing the system works out, every time, from the gap between what was promised and what is true now.

Take the four impellers. The payment lands and becomes one promise: four impellers, to this customer, by the eighteenth. That is all the payment does. Now the rules look at the gap. Four were promised; two are on hand. The gap is two impellers short, with a deadline. Every gap between a promise and reality is a job, and the rules find them the same way every time, in a few milliseconds.

For each job there is an act that closes it. Two short means a work order for two. The work order needs bronze bar, and there is none, so that is a new gap, and its act is an order to the foundry. The other two impellers mean a pick and a shipment. None of this is a template. The chain comes from the company’s own records: its bill of materials, the suppliers it used last time, the lead times it has actually seen.

Before any act happens, it looks for its authority. The foundry order falls inside Relay’s grant. The work order falls inside the production planner’s. The shipment falls inside the warehouse helper’s. An act that matches no grant simply does not happen. It becomes a question on the right person’s Today, and that person’s yes, with their passkey, is the authority.

Then the act is checked and written. The helper signs a typed action: what kind, on what, for how much, in what currency. Authority verifies it against the grant exactly: within amount, within scope, not expired, not revoked, not a replay. Only then does the hand write, the order into NetSuite, the email to the foundry, and only with a signed receipt. A refusal stops the act, shows why, and turns it into a question for a person.

The write changes the record, and the record changes the gaps. The bronze is now ordered, so that gap reads differently. When the foundry delivers, the work order can start. When the impellers are made, the shipment can go. When the carrier confirms, the outcome lands: delivered, on which day, at what margin. Each event runs the whole thing again from the state. Nothing stores the chain, so when the supplier’s email says a week late, the plan simply changes. Nobody has to find the workflow and edit it, because there was never one.

It is also safe to repeat. Every write carries a one-time id, so a retry cannot post twice. Every act has its receipt. If a grant is revoked halfway through, the next act finds no authority and becomes a question. There is no half-finished process to untangle, and that, more than speed, is why it can be trusted to run.

It comes down to five people, and what each of them gets.

The owner: fewer steps, more cash, nothing moved without authority. All three show up on her own books, before she has risked anything, and the agreement number from the shadow weeks is the proof. The headline is money and steps, not AI.

The controller: a better job, credited by name. She stops matching bills and starts deciding the few that genuinely need a person. The system learned from her, and it says so, every week. She is not being replaced by a machine; she is the person who taught it, and the record shows that.

The auditor and the regulator: a signed trail of every consequential act, with a named person behind each grant of authority. Human-led is not a policy here. It is how the thing is built.

The supplier and the customer: a record they can rely on without trusting either company’s word. Over time, kept promises accumulate into a history that says more about a business than any credit score, because it is made of what actually happened.

The company itself: a judgment that improves on its own outcomes, that it owns, and that stays its own. What is learned from one company’s promises and results belongs to that company. Nothing about it leaves.

It is not a new ERP. An ERP is forms, workflow and a ledger in one box, and companies spend years moving from one to another. Here the ledger stays where it is. The forms and the workflow stop mattering because nobody opens them, and one day the company notices it is paying a licence for a database.

It is not an agent bolted onto today’s software. Part II is about why: those make the same steps faster, and the step was the problem.

It is not a model that answers questions. A model that answers and never finds out whether it was right cannot be taught. The judgment here lives where the promise and the result meet, and that is the only place it could learn anything.

It is not a place to talk about work. A chat channel has no outcome; the conversation never resolves. A promise does. It carries money, it is kept or broken, and it is the same record on both sides of the wall between two companies.

And it is not a set of rules about what software may do. Those decide by policy, or by a model’s opinion. Here a person’s grant is the authority, the check is exact, and anyone can verify the result afterwards. Authority rather than permission. Proof rather than policy.

None of this is worth doing unless it clears five bars, and they are easy to state.

Judgment in milliseconds, so the screen a person opens in the morning is instant and a helper never waits on a model to think. Authority exact: the same inputs, the same answer, every time, provable from the receipt. Acting only when sure, with the confidence honest, so that when the system says ninety-five, it is right ninety-five times in a hundred and asks a person the rest. Plugging in within the hour, with no one from outside the company in the room. And working for any company, in any industry, with any way of working, because the grammar underneath is the same for all of them.

Those are not features. They are the conditions under which a company can hand over a step and not take it back.

A company is its outcomes. Everything else is a step. The point of all of this is to have fewer of them.