Deeper Openfort

Usually, year-end memos in crypto read like victory laps (or therapy sessions). But this time the interesting part isn’t who shipped more—it’s that the underlying rails are finally changing.

2025 made one thing painfully obvious: stablecoins aren’t “a crypto feature.” They’re becoming the default settlement layer for anything that wants to move money globally without inheriting a Byzantine stack of banks, middleware, and “trust me bro” reconciliations. When the rails change, the entire fintech stack gets rebuilt—often by teams who don’t look like banks, and don’t want to become banks.

This memo is how Openfort is preparing for 2026: what shifted in finance, what we built till now to be ready for it, and what we need to do next—separating “table stakes we can’t skip” from “bets that can actually make us win.”

The Quiet Shift

If you’ve been building in fintech for a decade, you’ve heard the blockchain pitch before. Distributed ledgers will change everything. Banks are dinosaurs. The future is decentralized.

Most of it was noise. But something shifted in the last two years—and it’s worth paying attention to.

Stablecoins crossed $300 billion in circulation. More interesting than the number is what’s underneath it: real businesses using stablecoin rails for real payments. Not speculation. Cross-border settlements, contractor payments, treasury operations. The boring stuff that actually matters.

The theoretical efficiency gain of stablecoins is massive: near-zero fees, instant settlement, no intermediaries taking a cut at every hop. But the theoretical pitch isn’t why stablecoins are winning. They’re winning because they’re fundamentally better infrastructure to build on.

If you’re building financial services today, stablecoins give you more control, more flexibility, and less friction than traditional rails. You’re not waiting on banking partners to add features. You’re not negotiating for access to basic capabilities. You can build what you want, how you want, for customers anywhere.

That’s the real unlock. Not that stablecoins are cheaper for every transaction today. It’s that they’re better plumbing for building the next generation of financial products.

The Moat Inversion

The old fintech playbook said: regulatory moats and banking partnerships are your defensibility. Technical execution is table stakes. Everyone can build software; not everyone can get a bank sponsor or a money transmission license.

That’s inverting.

Here’s why. In traditional fintech, the account is inseparable from the bank. You need a banking partner to give your customer an account. The bank holds the funds. The bank’s license is what makes the whole thing possible. That’s why banking relationships were the moat—without them, you couldn’t exist.

Programmable accounts break that coupling. The account becomes a smart account onchain. No bank required. No geographic restrictions. The customer’s assets exist at the protocol layer, controlled by keys, governed by code. You can set up an account for anyone, anywhere, instantly.

Once the account is decoupled, financial services become modular. Cards, fiat ramps, yield, payments—these become integrations you plug in rather than prerequisites to exist. A license becomes one capability in the stack rather than the foundation you build on.

The teams that win the next decade of fintech won’t be the ones with the most licenses. They’ll be the ones that can consistently execute on hard technical problems—and solve them in ways that compound.

What We’ve Built

Openfort started with a narrow problem: how do you give users a wallet without making them suffer through the crypto learning curve? Seed phrases, gas fees, transaction signing—these are implementation details that should be invisible. Users want outcomes, not infrastructure lessons.

The answer was account abstraction. Smart accounts that can pay for their own gas. Signers that don’t require hardware tokens. Authentication that feels like logging into any other app. We built the primitives that make self-custody feel like magic instead of homework.

Four years later, the infrastructure is real:

OpenSigner is fully open-source. Self-host your own key management. No vendor lock-in. If you don’t trust us—or if you just want control—you can run the entire signing infrastructure yourself. This isn’t a marketing claim; it’s architecture.

Account abstraction at scale. We’re one of the most competitive accounts in the ERC-4337 space—by wallet performance and gas cost. Signing takes ~200ms. The infrastructure handles millions of transactions without the user noticing they’re on a blockchain.

Multi-chain from day one. We started EVM-only, then expanded to Solana. Eight new chains this year alone. The goal isn’t to support every chain—it’s to support every chain that matters for the use cases we care about.

EIP-7702 support shipped before Pectra even went live. When the protocol layer evolves, we want to be ahead of it, not catching up.

The primitives work. The question now is what we do with them.

The Fintech 4.0 Bet

There’s a segment of the market that most infrastructure companies ignore: fintechs serving users who are explicitly excluded from traditional rails.

These users already pay 10-20% fees for basic financial services. They’ll pay for infrastructure that actually works. The use cases are constrained enough to build complete workflows, not just primitives. And revenue from these customers funds R&D that makes infrastructure cheaper for everyone else.

We call this Fintech 4.0—stablecoin-native financial services built on programmable accounts rather than legacy banking relationships.

The playbook is counterintuitive. Most infra companies try to build for everyone. The result: generic tools that require massive customization. We’re building for the edges first, then expanding.

Each of these should have a dedicated integration path—not just endpoints, but complete workflows. The goal is to make “launching a stablecoin fintech” as cheap as launching a SaaS product.

The Privacy Problem

Here’s the counterintuitive thing about blockchain adoption: most serious companies don’t want their transactions on a public ledger. Not because they’re hiding something—because they’re running a business.

Payroll, vendor payments, treasury movements, customer balances—none of this should be visible to competitors, analysts, or random chain observers. Competitive intelligence leakage is a real problem.

The privacy tooling that exists today is either too complex (ZK circuits that require PhDs to implement), too sketchy (mixers with compliance problems), or too limited (single-chain, single-use-case).

The answer is selective disclosure—prove what needs to be proven without revealing everything else. The tech exists but isn’t battle-tested yet. This is one of the hard problems we’re actively working on.

From Primitives to Workflows

We’ve built good primitives. Wallets, signers, gas sponsorship, smart accounts—all functional, all modular. But primitives aren’t products. Customers don’t wake up wanting “a signer.” They wake up wanting “onboarding that doesn’t lose users.”

A workflow is a complete path from intent to outcome:

• User signs up → wallet created → first transaction sponsored → confirmation shown. That’s onboarding.

• User deposits fiat → stablecoin minted → transfer sent → recipient withdraws. That’s payments.

• Game session starts → guest wallet created → assets minted → upgrade to full account on win. That’s gaming.

We should think in workflows, not endpoints. Not “here are the APIs” but “here’s how payroll works.”

The Risk Profile Shift

Any honest discussion of self-custodial infrastructure has to address FDIC insurance. It’s a real benefit. For US businesses, it provides genuine peace of mind.

But FDIC exists because fractional reserve banking creates risks that need insurance. It’s a solution to a problem created by the architecture itself. Banks take deposits and lend them out. If too many depositors withdraw at once—or if the bank makes bad loans—the system breaks. FDIC is the patch.

Stablecoin accounts on self-custodial infrastructure have a different risk profile entirely. No fractional reserve. Your funds sit in a smart account onchain. The intermediary risk disappears because the intermediary disappears.

This doesn’t mean no risk. It means different risk. Smart contract vulnerabilities. Issuer risk—if Circle fails, USDC has problems regardless of where you custody it. Key management failures. These risks are real, but they’re also transparent. You can inspect the code. You can verify reserves through attestations. You can see your assets onchain at any moment.

The theory is that FDIC protection is always better. The reality is that FDIC was designed to hedge against bad banking management—a problem that doesn’t exist when there’s no bank managing your funds in the first place.

Transparent trade-offs are easier to evaluate than opaque ones. When you understand exactly what can go wrong, you can decide if the architecture fits your risk tolerance. When your funds sit in a bank’s ledger, protected by insurance you hope you’ll never need, the risks are real but invisible until they aren’t.

The Modularity Thesis

In traditional fintech, the account is inseparable from the bank. The bank holds the funds. The bank’s license makes the whole thing possible. The bank’s API determines what you can build. If you want to add a feature, you ask the bank. If the bank says no, you’re stuck.

Stablecoin accounts break that coupling.

The account becomes a programmable object—a smart account with its own logic for who can access it and under what conditions. This isn’t a technical detail. It means the most fundamental thing—custody of assets and access control—doesn’t depend on a centralized service. It depends on the protocol and the chain.

Once the account is decoupled, everything else becomes pluggable. Need corporate cards? Integrate a card issuer. Need fiat connectivity? Plug in an on/off-ramp provider. Need local payment rails? Partner with whoever has that license in that market. Each capability becomes a module you can swap, not a prerequisite to exist.

Some teams building on stablecoins are making the old choice—assembling vendors, gluing pieces together, staying at the surface. That works until it doesn’t. You can’t move fast when you’re waiting on someone else’s roadmap. You can’t solve hard problems when you don’t control the layer where the problem lives. You can’t compound advantages when your capabilities are the same as everyone else using the same vendors.

Owning more of the stack means you can move faster. Ship what you need when you need it. Solve problems end to end. Build things that aren’t possible when you’re just integrating.

This is why we open-sourced OpenSigner. Not as a marketing gesture—as architecture. If you want to swap key management providers, you can. If you want to run the entire signing infrastructure yourself, you can. The account persists regardless of what happens to any single provider, including us.

The incumbents—Stripe, PayPal—are bolting stablecoins onto a legacy stack. They still have to maintain ACH, cards, wire transfers, their existing banking relationships, their compliance infrastructure across every jurisdiction. They’re not going to abandon that; it’s where their revenue comes from today. So stablecoins become another rail they support, integrated into twenty-year-old systems, subject to existing constraints.

A team starting today doesn’t have to make that choice.

Where the Bottlenecks Live

The bottleneck for traditional fintechs is local compliance and global reach. You need licenses in every jurisdiction. You need banking partners in every market. Expanding from the US to Europe to Asia means years of regulatory work and millions in compliance costs—before you serve a single customer.

The bottleneck for stablecoin infrastructure is different: rails to fiat in local markets.

This distinction matters because it changes the strategy entirely.

We’re live globally today because stablecoin accounts are global. The protocol is global. A business in Singapore and a business in Germany can both use our infrastructure and transact with each other immediately. Where we selectively add complexity is at the fiat edges—partnering with providers who handle card issuance and local payment rails in specific markets.

The core works everywhere. Fiat connectivity is additive, not foundational.

This is also why we’re skeptical of the “AI agents as investment vehicles” narrative. The theory is that autonomous agents will manage portfolios, make trades, execute complex financial strategies. The reality—at least for now—is that the infrastructure isn’t ready for that level of autonomy, and the regulatory questions haven’t been answered.

The real opportunity is agents as automations. Workflows that execute based on rules you define. Payroll that runs itself. Treasury operations that rebalance automatically. Compliance checks that happen without manual review. Not artificial intelligence making investment decisions—programmatic execution of decisions humans have already made.

This is where programmable accounts actually shine. The account itself can encode logic. Permissions can be granular. Spending limits, approval thresholds, time-based restrictions—these become features of the account, not policies enforced by a compliance team.

The teams that move fastest will be the ones that understand where the real bottlenecks are—and build around them instead of pretending they don’t exist.

What 2026 Looks Like

The infrastructure is mature enough to build real products. The market is forming. We’ve spent four years building for this moment.

The thesis is simple: the companies that win the next decade of fintech will be the ones that can leverage programmable accounts and stablecoin rails to deliver fundamentally better financial services. Not marginally better UI on existing rails—fundamentally different architecture that enables things that weren’t possible before.

The work ahead is clear. Ship workflows, not just primitives. Compress time-to-first-transaction. Build privacy infrastructure that’s compliant by default. Make the open-source story concrete. Solve hard problems end to end.

The foundation is real. Now we build on it.