We built a dead man’s switch on Tempo

Tempo went live yesterday. It’s a new L1 from Paradigm and Stripe, focused on stablecoin payments. We started experimenting with it during the testnet phase, and now that mainnet is live, we want to share what we’ve been working on.

Tempo is EVM-compatible (Solidity, same tooling you know), but the transaction layer does things no other EVM chain does right now:

• Scheduled transactions: sign now, set a future execution window with no keeper bots.
• Parallel transactions: partitioned nonce keys, so multiple transactions from the same account don’t step on each other.
• Batched calls: one transaction, multiple contract calls, atomic.
• Stablecoin gas: no native token, and fees are paid in stablecoins.

We wanted to stress-test what all these features actually enable, so we built something with them.

ifidie.run is a dead man’s switch for your crypto.

What’s a dead man’s switch? A mechanism that triggers an action automatically if you fail to check in. Originally used in trains and heavy machinery: if the operator lets go of a lever (or stops being alive), the system kicks in. In our case, if you stop checking in, your crypto gets moved.

The inner workings are simple. Set up a switch, pick how often you need to check in, and what happens if you fail to do so. By default, your balance gets transferred to a destination address, like a family member’s wallet or a backup.

People have tried building this before, but you always ended up needing smart contracts, token allowances, escrow, or dedicated wallets. Crypto doesn’t usually like it when actions get triggered by not doing something. On Tempo, you can make this work without any added bells and whistles. Your funds stay in your wallet. You go about your life (or lack thereof).

How it works

You create a switch by signing a scheduled transaction. This signed transaction sits off-chain, waiting.

Parallel transactions enable this pending transaction to sit idle even though your wallet may sign other actions in the meantime. The switch runs on its own dedicated nonce lane.

Scheduled transactions mean it cannot be included on-chain until the window opens. On a regular EVM chain, a smart contract could check the timestamp and revert if it’s too early, but that attempt still burns the nonce and costs gas, so the actual intended execution can never happen. Tempo rejects it at the protocol level. No gas spent, no nonce burned, no side effects.

When you check in, you send a noop transaction on the same nonce, which invalidates the old signature. And you sign a fresh one with a bumped nonce and a new deadline.

This is completely trustless. The signed transaction is time-locked at the protocol level. No one can execute it early, not our backend, not anyone else who holds a copy. In practice, this means it can be shared with a pool of keepers that would ensure its liveness and execute it when the time comes. You can even publish the payload on social networks if you want!

This works for any token or NFT. In theory, any contract call: transferring ownership, pulling liquidity from DeFi, triggering actions in other protocols.

What can be done with this?

The base mechanism needs no smart contracts. Extensions could layer them on top:

• On-chain wills: split assets across addresses by predefined rules
• Auto-recovery from DeFi positions if you go dark
• Emergency shutoffs across protocols
• Notifications to other contracts or parties

We also built an in memoriam page where you can pay respects to wallets whose switches have triggered. It’s morbid. We like it.

We’re Subvisual. We’ve been doing blockchain infrastructure for years, and Tempo caught our attention because the protocol itself handles things we used to need custom smart contracts and off-chain infra for.

Stripe and Paradigm are behind it. Mainnet launched alongside the Machine Payments Protocol, with Anthropic, Mastercard, Visa, and Shopify already in the mix. The stablecoin and institutional side is where we think this gets interesting for the kind of work we do.

One of the areas we’re most excited about is agentic payments. As autonomous agents become more capable, they increasingly need to transact: paying for datasets, compute, and APIs, or coordinating across multiple services in a single workflow. Traditional payment rails weren’t built for that volume or frequency. Tempo’s session-based payments allow funds to be allocated upfront and streamed in real time, making continuous, programmatic transactions viable at scale.

We’re building more on Tempo. If you are too, or if you’re thinking about stablecoin infrastructure, get in touch.