Here’s a thing nobody says out loud about AI software: it gets more expensive the more you use it.
Every request thinks from scratch. Every automation platform you bolt on adds another bill, another dashboard, another integration to babysit. The AI in the middle burns tokens re-deciding the same thing it decided yesterday. Usage goes up, so the cost goes up. That’s not a bug in one product. It’s the shape of the whole category.
ONE runs the other way. The more you use it, the cheaper it gets. Let me show you why, because it comes down to two decisions that almost nobody else made.
The whole engine is 200 lines
Not 200 thousand. Two hundred. One hundred lines of schema, one hundred lines of runtime, and that’s the complete thing. Six dimensions to hold anything that exists — groups, people, work, connections, events, and what the system learns. Six verbs to move it all.
You can read it in an afternoon. That matters more than it sounds.
Complexity can’t be deleted, only moved. Most software moves it toward you — more settings, more steps, more surface area you have to hold in your head. ONE moves it the other way, down into a runtime small enough to audit. The weight sits in the engine so the surface stays calm. A system you can read is a system you can trust, extend, and own. A hundred thousand lines of someone else’s framework is a system you can only hope about.
Small is not a limitation here. Small is the feature. It’s the reason the next two things are even possible.
Say it once, from any door
You run a business through conversation and code. Today those are two different worlds. Developers automate in repos. Operators click in dashboards. The two never quite agree, and you pay people to keep them in sync.
ONE makes them one world with one rule: work is a workflow, a workflow speaks one language, and every door reads and writes that same language.
- From your editor. Pull a workflow as JSON, or write it as plain TypeScript. Check it, push it, run a test, watch the logs. Your Claude Code session gets the same hands you have.
- From chat. “Build me an onboarding flow that waits for the signed contract, then invoices.” The agent builds it, checks it against the same language, and shows you the result.
- From a canvas. Drag the steps, hit test, watch the data move through node by node.
Same language. Same engine. Same memory. Build it once, from wherever you happen to be standing, and it runs everywhere. No translation layer, because there’s nothing to translate — it was one language the whole time.
The first trip takes thinking. Every trip after takes less.
This is the part that makes it cheaper.
Say “chase the unpaid invoices.” Something has to answer one question: who handles this? ONE answers it in one of three ways, and the three ways are the whole trick.
If it’s a request the system has seen work before, it goes straight to the answer. No model asked. No tokens spent. Free.
If it’s close to something known but not exact, a small, cheap model picks among the handful of options that actually apply. Fast and nearly free.
If it’s genuinely new, it gets real judgment — the expensive kind — which might even build the workflow on the spot. And here’s the move: that decision becomes a path the next request rides for nothing.
So the expensive thinking happens once. The tenth time you chase invoices, you’re on the free lane. The hundredth time, still free. Every request you make teaches the system, and a taught system stops paying to re-decide. Cost per outcome falls as volume rises. That is the exact opposite of how the rest of the category behaves.
And the work is durable while it learns. It survives restarts. It waits days without burning compute. It pauses for your approval with a button in Telegram, takes a payment mid-flow, and always reports back — even the run a webhook kicked off at 3am shows up as a finished task in your inbox.
Why this is the thing that wins
Whoever is fastest wins. The way to be fastest is to remove friction. The way to remove friction is power through simplicity — and simplicity is why all three of these are true at once. Two hundred readable lines is what lets one language run every door. One language is what lets the system learn across all of them. And a system that learns is a system whose cost bends toward zero.
Jeremy Rifkin called the destination in 2014: zero marginal cost. He was early on the mechanism. AI agents are how it actually arrives — one free lane at a time, each one paved by a decision you only had to make once.
Say it once. It gets done. And it gets cheaper every time you do.