Explanation
Hybrid AI Economics
The power of local and cloud working together.
There's a quiet assumption built into most AI tools: that every request should go to a large cloud model. It's a simple model to build, but it's an expensive way to work, and an unnecessary one. OOMU is built on a different premise: do as much as possible on the machine you already own, and pay for the cloud only when it genuinely earns its keep.
This page explains the economics behind that choice.
Two flawed extremes
Pure cloud is expensive, and you pay on every keystroke. When every message goes to a frontier model, you pay per token, every time, forever. A quick "tidy up this sentence" costs the same kind of money as a deep legal analysis. Costs scale linearly with use, which means the more useful the tool becomes to your team, the more it costs you. And every one of those requests carries your data off your machine.
Pure local is cheap, but it has a ceiling. Running everything on a local model is private and free per request, but the largest, most demanding reasoning tasks can exceed what an on-device model does best. If local were your *only* option, you'd occasionally hit a wall on the hardest problems.
Neither extreme is the right default. The answer is to use each for what it's best at.
OOMU's approach: local first, cloud when it counts
OOMU treats your Mac as the first responder and the cloud as the specialist consult.
- Most requests never leave your Mac. Drafting, summarising, rewriting, answering questions, reasoning over a document you've attached; your on-device model handles these directly. Per-request cost: nothing.
- OOMU scores each request before spending a cent. With Auto-Route, OOMU measures the complexity of every message. Below a threshold, it answers locally for free; only when a prompt crosses that threshold does it escalate. This isn't a guess made once and applied forever; it's a per-message decision.
- The cloud is a deliberate choice, not a default. When a prompt does warrant it, OOMU routes to the one cloud provider you've nominated as your Auto-Route target; using your API key. If you haven't nominated one, it falls back to a deliberately cost-efficient model rather than the most expensive option.
The effect is that your spend tracks *difficulty*, not *volume*. You stop paying frontier prices for routine work.
Where the savings come from
Three mechanisms do the heavy lifting:
1. Local handling of the routine
The single biggest lever. If most of your messages are everyday work, and for most professionals they are; then most of your messages cost nothing, because they run on hardware you already own.
2. Local pre-processing before any cloud call
When OOMU does reach for the cloud, it doesn't have to send everything. OOMU prepares and bounds context on your Mac first; reading and trimming the relevant material locally, within strict size limits, so the cloud model receives a focused, right-sized request rather than a bloated one. Smaller, sharper requests cost less and often answer better.
3. Right-sized reasoning
OOMU's reasoning levels let you match effort to the task. A quick reply doesn't need maximum deliberation, and OOMU won't spend it. You dial up depth only where accuracy matters, see Smart Model Routing.
An illustrative picture
The exact numbers depend on your workload and which cloud provider you configure, but the *shape* is consistent. Consider a professional sending 1,000 messages in a week:
| Approach | What happens | Relative cost |
|---|---|---|
| Pure cloud | All 1,000 messages billed to a frontier model. | Highest; you pay for every message, including the trivial ones. |
| OOMU hybrid | The routine majority resolve locally for free; only the demanding minority reach the cloud, with pre-trimmed context. | A fraction of the above; you pay only for the hard work, on smaller requests. |
The lever is the ratio. If even a large share of those 1,000 messages are everyday tasks that run locally, the bill for the week collapses toward the cost of just the few that truly needed a frontier model; while those few still get full, elite reasoning.
The point isn't that the cloud is bad. It's that paying frontier prices for a one-line rewrite is waste. OOMU removes the waste and keeps the capability.
Quality doesn't pay the price
Cutting cost usually means cutting corners. Here it doesn't, because nothing about this approach caps the ceiling:
- The hard questions still go to frontier models; at full strength, with focused context.
- The routine questions are handled by a capable local model that's more than sufficient for them.
- You set the policy. Primary engine, fallback engine, reasoning depth, and whether OOMU may reach the internet at all are all yours to decide.
You're not trading quality for savings. You're refusing to overpay for the work that never needed the premium tier in the first place.
The economic case in one line
Pay for intelligence in proportion to difficulty; not in proportion to how often you hit Enter.
Related
- Smart Model Routing: set up the local/cloud balance yourself.
- System Design Overview: the local-first architecture this rests on.
- Privacy & Sandboxing: why keeping work local protects more than your budget.