u/Bisu40

I’ve been exploring a problem in the crypto/blockchain space around handling agreements between parties, not just value transfer.

Most systems today are really good at moving funds, but when it comes to things like escrow, milestone payments, or conditional outcomes, a lot of it still ends up being handled off-chain or through custom logic.

I started working on an open-source project (Irium) to experiment with whether this can be handled more natively — focusing on ideas like:

– defining agreements upfront
– using objective conditions (timeouts, signatures, proofs)
– minimizing subjective dispute resolution

It’s still early and very much an exploration, but I’d really appreciate feedback from people here, especially on:

– whether this belongs at protocol level vs application layer
– how to handle verification of real-world conditions
– where trust inevitably creeps back in

Repo: https://github.com/iriumlabs/irium

Happy to hear any thoughts or criticism.

u/Bisu40 — 15 days ago

Crypto is supposed to reduce or remove trust when it comes to transferring value between parties.

But in real-world situations like buying something, hiring someone, or making agreements, you still end up trusting the other side to follow through.

Even with smart contracts, there’s often some dependency on off-chain actions or verification.

Why do you think this gap still exists?

reddit.com
u/Bisu40 — 16 days ago

Crypto handles transferring value pretty well, but real-world transactions usually involve agreements, conditions, and trust between people.

What do you think is still missing for crypto to handle that side in a practical way?

reddit.com
u/Bisu40 — 16 days ago

Most chains are really good at transferring value.

But when it comes to actual agreements between parties — escrow, milestone payments, deposits/refunds — it usually ends up being handled off-chain or through custom app logic.

That feels like a missing primitive.

Right now typical approaches are:

  • centralized escrow services
  • multisig setups with coordination overhead
  • or smart contracts that still rely on external context

I’m wondering whether this should be handled more natively at the protocol level.

For example, a system where:

  • agreements define conditions upfront
  • funds move based on objective outcomes (timeouts, signatures, proofs)
  • no subjective dispute resolution is needed

Basically treating settlement as a first-class concept instead of just transfer.

Curious how people here think about this:

  • Is this something that belongs in the base layer?
  • Or is it better kept in higher-level abstractions?
  • What are the biggest design constraints to keep it objective and trust-minimized?
reddit.com
u/Bisu40 — 17 days ago