What Is Safe (Formerly Gnosis Safe)? The Multisig Smart Account Explained

If you have ever wondered where DAOs, foundations, and crypto institutions actually keep their money, the answer is almost always the same contract: Safe. Safe — formerly Gnosis Safe — is the industry-standard smart-account multisig: an Ethereum smart contract that holds assets and only releases them when a pre-set threshold of authorized owners sign off. It is not an app or a browser extension so much as a piece of financial infrastructure, and it secures tens of billions of dollars for the likes of Uniswap, Aave, and Lido. This is the full picture — how it works under the hood, whether it has a token, the numbers, and the hard lessons from the biggest hack in crypto history, which ran through a Safe without breaking it.

What Safe is and who built it

Safe is a self-custodial smart contract wallet built on the principle that no single key should be able to move funds. Instead of one seed phrase controlling everything — the fatal flaw of ordinary wallets — a Safe defines a list of owners and a threshold: a "3-of-5" Safe needs three of its five owners to approve any transaction before it executes. That single design choice removes the single point of failure that has drained countless individuals and projects.

Its history runs to the origins of Ethereum tooling. In 2017, Gnosis co-founder Stefan George wrote a multi-signature wallet to custody the proceeds of the Gnosis ICO; it was open-sourced as the Gnosis Multisig. In 2018 the team rebuilt it from scratch as Gnosis Safe, a general-purpose smart account. By 2022 it had outgrown its parent: GnosisDAO spun the project out, and it rebranded to Safe alongside a $100 million raise led by 1kx, with Lukas Schor and Richard Meissner among the co-founders. Today it is stewarded by the Safe Ecosystem Foundation and governed by SafeDAO. That lineage matters — Safe is one of the oldest continuously-used contracts in the ecosystem, and longevity is a form of security in itself.

How Safe actually works: proxies, singletons, modules, and guards

Here is the part most explainers skip. A Safe is not one monolithic contract per user. Every Safe you deploy is a lightweight proxy contract that holds your configuration — owners, threshold, balances — but delegates all its logic to a shared singleton (also called the master copy or implementation). This is deliberate:

• Cheap deployment. Spinning up a new Safe just deploys a thin proxy, not a full copy of the logic, keeping gas low.
• Concentrated security. All the critical code lives in one heavily-reviewed singleton, so audits and formal verification focus on a single, shared target rather than thousands of copies.
• Upgradeability by choice. Owners can point their proxy at a newer singleton if they choose to — letting an account adopt new signature schemes in future (including post-quantum ones) without migrating funds to a new address.

On top of that base, Safe's real superpower is modularity. Two extension points turn a static multisig into programmable infrastructure:

Modules are separate contracts a Safe authorizes to move funds via execTransactionFromModule — without collecting the full threshold of signatures. That sounds dangerous, and it is powerful, so modules are opt-in and scoped. Common production modules include:

• Allowance Module — lets a designated address spend up to a set amount per period (a team paying a contractor without a full multisig ceremony each time).
• Recovery Modules — from Safe and third parties, letting a guardian replace lost signers after a time delay, giving you social recovery without a seed phrase.
• Safe 4337 Module — makes a Safe behave as an ERC-4337 account, accepting UserOperations so it can be used with account-abstraction infrastructure, paymasters, and gas sponsorship.

Guards work in the opposite direction: they run before and after every transaction to restrict what the Safe can do. A guard can enforce an address whitelist, cap transaction size, or block certain operations entirely — useful when an institution wants hard policy rails around even its own signers.

The net effect: the base is a boringly-secure threshold multisig, and everything programmable is bolted on as opt-in modules and guards. That separation is why almost every treasury tool, DAO governance system, and institutional custody workflow in the space is built around Safe rather than reinventing it.

The SAFE token: governance first, security second

A crucial clarification for newcomers: you do not need any token to use a Safe wallet. You pay ordinary network gas in ETH (or the chain's native asset), and that is it. There is no "Safe fee token" gating access to your own multisig.

SAFE is a distinct thing — an ERC-20 governance token for SafeDAO, distributed via an airdrop in October 2022 to users and ecosystem contributors. It launched non-transferable: holders could vote and govern, but not trade, for nearly two years. After a series of governance milestones, a vote with over 99% approval un-paused the contract, and SAFE became transferable in April 2024. It has a 1 billion total supply with allocations to community treasuries, core contributors, backers, the Foundation, and users, vesting on a schedule that extends toward 2030.

Through 2024–2025 SAFE was essentially a pure governance token — steering upgrades, treasury decisions, and grants. In 2026 it gained its first live economic function: staking to help secure Safenet (below). Validators stake SAFE to run the network and delegators can back them for rewards, marking SAFE's evolution from a governance asset into a network-security asset. It is a genuine utility milestone — but treat SAFE as what it is, a volatile governance/security token, not a requirement for using Safe wallets.

The numbers: how much Safe secures

Safe's scale is the strongest argument for its dominance. By 2026 it secures tens of billions of dollars across more than 60 million accounts on over a dozen EVM chains, with the project citing well over $100 billion in cumulative assets protected and billions of dollars in monthly transfer volume. Public TVL trackers on DefiLlama consistently place Safe among the largest non-custodial custody platforms in crypto.

More telling than raw TVL is who uses it. The largest DAOs in the industry — Uniswap, Aave, MakerDAO, ENS, and Lido — publicly manage their core treasuries through Safe. Professional treasury managers like karpatkey, Llama, and StableLab run Safe-based workflows for dozens of organizations. Beyond DAOs, exchanges, market makers, and asset managers use Safe for hot- and warm-wallet segregation, and several Bitcoin-bridging protocols use a Safe as the canonical guardian set over their reserves. When people call Safe "the default treasury layer of Ethereum," the concentration of serious money behind it is why.

The ecosystem: Safe{Core}, Safe{Wallet}, and Safenet

Safe ships as a few distinct layers worth separating:

• Safe{Core} — the open-source smart contracts and SDKs that developers build on. This is the protocol.
• Safe{Wallet} — the official web and mobile interface most people mean when they say "Safe wallet."
• Safenet — the 2026 expansion. Pitched as an "onchain VisaNet," Safenet is a decentralized transaction-processing network that gives users a unified balance across chains and uses an intents-and-solver model to settle cross-chain transfers in roughly a second, with processors staking SAFE and posting liquidity to guarantee execution. Safenet Beta launched at EthCC in 2026, letting SAFE holders delegate to genesis validators and earn staking rewards. It is Safe's bid to move from "the place funds sit" to "the network funds move through."

Because Safe{Core} is open and permissionless, hundreds of applications integrate it — governance platforms, DeFi dashboards, payroll and grants tools, and custody providers all speak "Safe" natively. That integration depth is a moat: even if a rival multisig were technically superior, the tooling gravity around Safe is enormous.

Why Safe won over the alternatives

It is worth understanding why Safe, specifically, became the default rather than one of the many multisig or custody designs that competed with it. The main rival to onchain multisig is MPC (multi-party computation) custody, where a private key is mathematically split across parties and signatures are produced off-chain. MPC has real advantages — it looks like a normal single-signer wallet on-chain and works on chains without smart contracts — but it is opaque: the signing policy lives in a provider's off-chain infrastructure, not in a public contract you can inspect. Safe made the opposite bet. Its rules — owners, threshold, modules, guards — are fully on-chain, transparent, and auditable by anyone. For a DAO that must prove to its community exactly who can move the treasury, that transparency is not a nice-to-have; it is the entire point. Combine that with open-source contracts, years of clean track record, and the deepest integration ecosystem in crypto, and Safe's dominance stops looking like luck.

How to actually use Safe

At a practical level, setting up and running a Safe follows a consistent pattern:

1. Create the Safe. Go to the official Safe{Wallet} app, connect a signer wallet, choose the chain, and deploy. Deployment costs a small amount of gas.
2. Add owners and set the threshold. Add the addresses that will control the Safe and pick your M-of-N. For a serious treasury, spread owners across different people and different hardware wallets — the whole point is that no single compromised key is enough.
3. Fund and transact. Send assets to the Safe address like any wallet. To move funds, one owner proposes a transaction; the others confirm until the threshold is met; then anyone executes it.
4. Extend if needed. Add an allowance module for routine spending, a recovery module for signer loss, or a guard to enforce policy — only if you need them.
5. Verify on hardware. The single most important habit: when you sign, confirm the transaction details on your hardware wallet's own screen, not just in the browser. This is the discipline the Bybit victims lacked.

A sensible default for most teams is 3-of-5 with keys held by different individuals; solo users often run 2-of-3 across a hardware wallet, a phone, and a backup.

Risks and what to watch

Safe's contracts are exceptionally well-tested — open-source, audited by multiple firms, formally verified, and running for years across billions in value with no contract-level exploit. That is the good news. The risks live elsewhere:

• The frontend and the signer, not the contract. The February 2025 Bybit hack is the defining case study. Attackers linked to North Korea's Lazarus Group compromised a Safe developer's machine, injected malicious JavaScript into the Safe web interface that Bybit used, and showed signers a normal-looking transaction while it actually transferred control of the cold wallet. Roughly $1.5 billion in ETH vanished — the largest crypto heist ever — and the Safe contracts did exactly what the signers signed. The takeaway is not "Safe is unsafe"; it is that a multisig only protects you if signers independently verify what they approve, ideally on hardware.
• Blind signing. If your owners approve transactions they cannot read, the multisig's protection collapses to zero. Use tools that decode calldata and confirm addresses and amounts on-device.
• Module and guard risk. Every module you authorize can move funds under its own rules. A buggy or malicious module is a hole in your Safe. Add only audited modules you understand.
• Governance and key management. Losing enough signer keys to drop below your threshold can lock funds; concentrating keys with one person or one device reintroduces the single point of failure you were trying to remove.
• SAFE token volatility. If you hold or stake SAFE, it is a volatile asset, and Safenet staking adds smart-contract and slashing-style considerations of its own.

Bottom line

Safe earned its position the boring way: by being the contract that did not break while it held tens of billions of dollars for the most important organizations in crypto. Its smart-account model — a proxy over an audited singleton, extended by modules and guards — turned the humble multisig into the programmable base layer that most of onchain finance is built on. The SAFE token and Safenet push it toward being a network rather than just a vault, which is genuinely ambitious. But the enduring lesson is the one the Bybit disaster taught at a $1.5 billion price: Safe removes the single-key point of failure, and in return demands that its signers stay disciplined. Verify what you sign. The contract will hold; make sure your process does too.

Related guides

• Safe reviewed
• ENS
• Account abstraction
• Ledger review
• Crypto wallets

Not financial advice. SAFE is a volatile token and self-custody carries risk — always verify contract addresses and transaction details on official Safe channels and your own hardware wallet.