Pace: Protecting Cash When Income Doesn’t Come on a Schedule
Most budgeting tools assume money arrives regularly. A lot of people don’t live like that.
I work across trading, bounties, and hackathons. Some weeks are good. Others are quiet for longer than expected. The hard part isn’t knowing I should set money aside. It’s that I keep misjudging how long the quiet period will actually last. I’ll spend like the next payout is closer than it is, then find myself short right before something finally lands.
That’s the problem Pace tries to handle.
Pace is a small cash-flow tool that learns how long the gaps between payouts usually are, then protects enough money so the dry stretches are less stressful. It stores those patterns in Walrus Memory. The blockchain stays in the background.
What it learns
When money comes in, Pace records the episode. Over time it picks up:
How many days typically pass between real payouts
A rough sense of daily spending
When recurring costs tend to fall inside a longer gap
It uses a simple rule:
textRunway Reserve = (Learned Drought Days × Daily Burn) + Upcoming Bills + Safety Floor
True Surplus = max(0, Cash on Hand − Runway Reserve)
On a cold start it uses generic assumptions and can sweep too much. After a few real cycles are stored, it gets more careful with the amount it leaves available.
How it uses Walrus Memory
Walrus Memory is the only place Pace stores history. Each episode (a payout, a dry stretch, a bill cluster, or a user override) is written as an encrypted memory on Mainnet through the hosted relayer.
The app recalls the latest profile when it needs to decide how much to protect. Newer memories update the learned drought length, daily burn, and confidence. Because the memories live on Walrus, the pattern survives across sessions instead of resetting every time the app is opened.
In the demo, the “Replay 60-Day Cycle” button writes a realistic set of episodes so you can see the profile change in one go. In normal use those writes happen as real payouts and gaps are logged.
How it uses Tatum
Tatum’s Sui RPCs are used for the chain context around each memory. When an episode is stored, Pace anchors it with a live Sui checkpoint. That gives the memory a verifiable point in time without requiring the user to deal with wallets or gas.
The primary interface never shows raw chain data. Tatum stays in the background so the app can still confirm that memories were written against real Mainnet state.
How it learned over time
At the start Pace assumes a short gap and a modest daily burn. After several cycles are stored, the numbers shift. A 14-day assumption can move to 24 or 25 days. Recurring costs get reserved. Confidence rises.
The clearest proof is the comparison the dashboard shows: how much extra cash was protected on a new payout versus what a cold-start version would have swept. That difference comes directly from the memories already written.
What’s real and what’s simulated
Memory writes and recalls use Walrus on Mainnet once credentials are set.
The runway math and the before/after comparison are real.
The actual surplus sweep into another wallet is simulated in the current version. The decision is calculated and shown; the on-chain transfer can be added later.
What I learned building it
The calculation itself is straightforward. The harder part was making the memory feel useful. If the app only said it had “learned,” it wouldn’t mean much. So the dashboard shows the current drought estimate, confidence, and exactly how much extra was held back because of past episodes.
It’s still early. The tool is shaped around inconsistent income rather than a fixed paycheck. But the loop works: remember what the gaps looked like, then use that the next time money shows up.
If your income comes in bursts and the quiet periods are hard to predict, that’s the situation Pace is built for.
