The decision you made on Tuesday is already stale on Thursday

On Tuesday you priced the deal at a discount, because the supplier quote you were holding said your margin could absorb it. It was a good decision. You had the numbers in front of you, you did the math, you sent the proposal. Then on Wednesday the supplier raised their price, and on Thursday the deal you’re still chasing, at Tuesday’s discount, quietly stopped making money. Nobody told you. The proposal is out there closing, and the premise under it died two days ago.

That’s the failure nobody builds for. Not a wrong decision. A decision that was right when you made it and went stale while you weren’t looking.

Every tool you own will happily store that Tuesday number forever and never once mention that the ground under it moved. This post is about the one property that fixes that, and why almost nothing you use today has it.

The decision is an event; the premise is a living thing

Here’s the model baked into every app you open. A decision is a moment. You gather the inputs, you choose, you record the outcome, the price is set, the hire is approved, the roadmap is locked, and then the system files it. Done. The record sits there, accurate as a photograph and just as frozen.

The trouble is that the inputs you decided on don’t sit still. The quote expires. The exchange rate drifts. The competitor drops their price. The candidate takes another offer. The regulation changes. Every decision rests on a stack of premises, and premises rot at their own pace, on their own schedule, with nobody watching the clock.

So the decision and the world it was based on slowly come apart. And the system that recorded the decision has no opinion about this, because it was only ever built to remember what you chose, never to keep checking whether you’d still choose it.

A reactive app never tells you the premise changed. A coworker re-checks the math.

That’s the whole thesis, and it’s worth sitting with. The gap isn’t between a dumb tool and a smart one. It’s between a tool that stores your conclusion and a coworker who quietly keeps re-running the math behind it, and taps you on the shoulder the day the answer flips.

The naive version: a database of decisions nobody re-opens

The way we handle this today is to write the decision down somewhere good. A deal desk. A pricing sheet. A doc titled “Q3 hiring plan, FINAL.” We’re proud of the record. It’s clean, it’s searchable, it’s the single source of truth.

And it fails the same way every time: a source of truth is only true at the instant you write it.

The pricing sheet doesn’t know the supplier quote it’s built on expired. The hiring plan doesn’t know the budget it assumed got cut in a meeting it wasn’t in. The roadmap locked in January doesn’t know that the customer it was built to win signed with someone else in March. The record stays confidently, articulately wrong, and because it’s written down so well, it’s more trusted than the messy reality that’s drifted away from it.

You only discover the rot on contact. The deal closes at a loss. The offer goes out at a budget that’s gone. The quarter ends and you realize you spent it executing a plan whose reason for existing expired in week two. The record never lied to you. It just never updated, and you mistook stillness for staying true.

Same decision, two fates. In one, it’s a photograph that yellows. In the other, it’s a claim that stays under watch. Nothing about the decision itself is different, only whether anything kept checking it after you walked away.

Why a chatbot can’t save you here

You might think the fix is to ask. Open the assistant, type “is my Q3 pricing still good?” and let it check. And for the one decision you remember to ask about, that works.

The problem is the same one that breaks every reactive tool: you have to know to ask. You’d have to wake up Thursday already suspecting that this particular deal, out of the forty you’ve made this month, rests on a premise that moved. But the entire reason stale decisions hurt is that they look exactly like fresh ones. There’s no alarm bell on a number that’s quietly gone wrong. The proposal still says the discount. The sheet still says the margin. Everything looks fine, which is precisely why nobody re-checks.

So the burden of remembering which of your hundred past decisions might have gone stale lands back on you, the one job a human is worst at. We don’t forget to re-check out of laziness. We forget because re-checking a hundred frozen premises against a world that’s always moving is not a thing a brain can do. It’s a thing a system that never sleeps can do.

A chatbot waits for the question. The question here is one you’d never think to ask, until it’s already too late to ask it.

The coworker version: decisions that watch their own premises

Now the version worth building. The key idea is simple: you stop storing a decision as a dead record and start holding it as a live claim, a conclusion with its premises attached, each premise tagged with the source it depends on and the condition that would flip it.

The Tuesday pricing decision doesn’t get filed as “discount: approved.” It gets held as: this discount is profitable as long as the supplier quote stays at X and the volume stays above Y. Those two clauses aren’t notes. They’re tripwires. The supplier quote is wired to the document it came from; the volume is wired to the live number. The system isn’t storing your answer. It’s storing the math that produced it, and the math is connected to the world.

Then the system does the thing you can’t: it keeps the math running. Quietly, in the background, against premises that never stop moving. The supplier raises their price on Wednesday, the tripwire trips, the claim that was true on Tuesday is now false, and instead of you discovering it on contact three weeks later, you get a sentence on Thursday morning. The discount you approved Tuesday no longer clears margin, the supplier quote went up 8%. Want to re-price, or hold and eat it?

Notice what that sentence carries. Not just the alert, the reason, and the next move. It re-ran the math, it tells you which premise broke, and it brings you the decision back to the surface while you can still do something about it. That’s not a smarter database. That’s a coworker who remembered the deal you’d forgotten and re-checked it without being asked.

The loop is the product. A frozen record runs that loop exactly zero times. A coworker runs it on every premise, on every pass, forever, and only ever interrupts you on the pass where the answer changed.

Your company is a graveyard of stale-but-confident decisions

Once you see decisions as living claims, you see the graveyard everywhere, every place a choice outlived its reason and kept getting executed anyway.

The budget approved against a forecast that’s since been cut in half, still being spent line by line. The vendor you picked because they were cheapest, who raised prices twice while the contract auto-renewed on the old logic. The headcount plan built for a market that turned, still hiring for roles the turn made pointless. The feature greenlit because a big customer asked, long after that customer churned and took the only reason with them. None of these were bad decisions. Every one of them was a fresh decision that nobody re-opened once the premise underneath it quietly expired.

This is the work that doesn’t fit in any app, because it isn’t a task and it isn’t a question. It’s a standing obligation to re-check, and a standing obligation is exactly the thing humans drop and an always-on system never does. The cost isn’t the occasional bad call. It’s the slow, invisible drift of a whole company executing last month’s logic in this month’s world, perfectly, confidently, and a little bit wrong in a hundred places at once.

The turn: judgment was never the part that decayed

Strip the software question away for a second and ask what actually happened to you on Thursday. You didn’t lose your judgment. Your judgment was fine, it was correct, given what you knew on Tuesday. What you lost was the bandwidth to keep re-validating a decision you’d already made, against a world that wouldn’t hold still long enough for you to catch up.

That re-validating is not the interesting part of your job. It’s the opposite. The interesting part is the call itself, weighing the discount against the relationship, choosing who to hire, deciding what the company chases this quarter. That’s the work only you can do, and it’s the work that gets crowded out when you’re also the only thing standing between a hundred old decisions and the moment their premises rot. You were never bad at deciding. You were just never built to be the watchman over every decision you’d ever made.

So let the math re-run itself. Let the premises wire to their sources and trip their own alarms. Keep, for yourself, the only thing that was ever yours: the judgment to make the call in the first place, and the judgment to remake it, on purpose, the morning something tells you the ground moved.

When that lands, your best decisions stop quietly expiring in the dark. Something is re-checking them, and it speaks up the day the answer changes.

---

That’s what we’re building at Apollo Space: not a place to file your decisions, but something that keeps re-running the math underneath them and finds you the morning a premise breaks. The decision you made on Tuesday was good. You just deserve to be the first to know, not the last, when Thursday makes it stale.