Welcome to Salt
Salt is programmable signing infrastructure that coordinates the management of digital assets with multiple signers.
Your organisation's systems propose transactions, Salt checks them against your policies, and a quorum of signers your organisation controls signs them.
Salt never holds a keyshard and cannot sign on its own, so control of your assets stays with you rather than with your infrastructure provider.
What you can do with Salt
- Manage your treasury
- Put shared funds under multi-party control, with policies checked before anything is signed
- Use one address across every supported EVM chain
- Keep every keyshard with your own signers, never with Salt
- Automate trading and operations
- Run strategies, bots, and agents from policy-controlled accounts
- Let Robo Guardians co-sign around the clock for transactions that pass your policies
- Delegate execution without giving up custody
- Build an app on Salt
- Embed self-custodial wallets in your product with the Salt SDK
- Sponsor fees so your users don't have to handle them
- (coming soon) Give your users a direct view of their Salt-backed holdings in the Salt app
Who uses Salt
- Trading firms and funds run strategies, bots, and agents from accounts with programmable guardrails.
- Asset managers run separately managed accounts (SMAs), deploying their clients' funds without taking custodial control.
- Fintechs embed self-custodial accounts in their own product through the Salt SDK without taking custody of user assets.
- Projects and treasuries put shared funds under multi-party control with policies checked before anything is signed. Routine flows such as sweeps, payouts, and rebalancing can run automatically when they pass policies. Salt runs its own fee revenue this way.
One account, many EVM chains
A Salt account behaves like an EOA. The same account address can be used across EVM chains, without deploying a separate smart contract wallet on each network.
This makes Salt useful for organisations that operate across chains, and for fintechs that want to give users a consistent account layer without rebuilding wallet infrastructure chain by chain.
Policies before signatures
Salt separates transaction coordination from cryptographic signing.
Before a transaction is signed, Salt checks whether the proposed action complies with the account’s active policies. Policies can restrict things like destination addresses, transaction size, functions, assets, timing, and signer permissions.
If the transaction passes policy checks, Robo Guardians can participate in the signing flow. If it does not, they do not co-sign.
This allows organisations to delegate execution to humans, bots, agents, or third-party managers without giving them unrestricted control over assets.
Automated co-signing
A key property of Salt's architecture is that users are not required to wait for other proposers when proposing a transaction. To enable this, Salt has introduced Robo Guardians.
Robo Guardians are self-hosted automated co-signers for Salt accounts.
Robo Guardians hold one part of an organisation’s signing quorum and co-sign only when a proposed transaction satisfies the organisation’s policies. They are designed to stay online when proposers are not, so approved workflows can continue without waiting for manual approval every time.
Once a transaction satisfies policy requirements:
- The Robo Guardians immediately participate in the signing ceremony
- Threshold signatures are generated automatically
- The transaction can be broadcast without requiring additional user interaction
- This enables transactions to be processed quickly while still benefiting from MPC-based security and policy enforcement
Each Robo Guardian runs on infrastructure chosen by the organisation. The organisation can run it on its own hardware or cloud environment, or delegate hosting to a third party it trusts.
Salt coordinates with Robo Guardians, but does not host them, control them, or hold their key material.
Learn more about Robo Guardians
Salt MPC vs Multisig
While Salt requires multiple underlying signers to authorise transactions, it is not a traditional on-chain multisig wallet.
Traditional multisig wallets typically:
- Store approval logic in an on-chain smart contract
- Require multiple participants to submit approvals on-chain
- Form the transaction through smart contract execution
Salt operates differently.
- Transaction orchestration occurs off-chain
- Threshold signatures are produced using multi-party computation
- The blockchain receives a fully signed transaction rather than individual approvals
- From the blockchain's perspective, the transaction appears as a standard signed transaction rather than a multisig contract execution
Salt vs hosted MPC
Hosted MPC solved single-key risk, but in many setups the provider still sits inside your signing quorum. It holds a keyshard or runs the automated co-signer, and recovery runs through its process.
With Salt, you keep the benefits of threshold signing, and the whole signing quorum is yours. Salt coordinates, but never signs.
| Salt | |
|---|---|
| Key shards | Salt holds none. Each shard is generated on your signers' own devices and servers, not created by Salt and handed over |
| Automated co-signing | Robo Guardians run on infrastructure you choose |
| Recovery if Salt is unavailable | Encrypted shard backups are stored on-chain, and recovery is designed to work without Salt |
| Pricing | Pay per action, with no seats or subscriptions |
Salt is permissionless to onboard and use. Get started with the SDK.
Where Salt fits
Salt is the wallet and signing layer between your organisation's finances and the chain.
The chain sees an ordinary signed transaction from an ordinary address. There is no smart contract wallet to deploy and nothing chain-specific to integrate.
+----------------------------------------+
| Your organisation |
| trading, treasury, bots, agents, apps |
+----------------------------------------+
| proposals via the Salt SDK
v
+----------------------------------------+
| Salt |
| accounts, policy checks, coordination |
+----------------------------------------+
| signing requests, if policy passes
v
+----------------------------------------+
| Your signers |
| team wallets + self-hosted co-signers |
| (Robo Guardians) |
+----------------------------------------+
| standard signed transaction
v
+----------------------------------------+
| Blockchains |
| any supported EVM chain, one address |
+----------------------------------------+
Ways to use Salt
Use the Salt SDK
Salt is an SDK-first platform: everything Salt does is available through the Salt SDK, and the Salt app is built on it too. Use the SDK to create organisations, accounts, policies, and transaction flows programmatically.
Use the Salt SDK to create organisations, accounts, policies, and transaction flows programmatically.
This is the right path for developers, automated services, bots, agents, and teams building their own interface on top of Salt.
Refer to the SDK documentation for technical guidance.
Use the Salt app
Coming soon: The Salt app is a browser interface for creating organisations, adding collaborators, creating accounts, configuring policies, and managing transactions.
Embed Salt in a fintech application
Fintechs can use Salt as wallet infrastructure inside their own product. Their users can onboard through the fintech’s interface while still having Salt-backed accounts, which they will also be able to view in the Salt app once it launches.
Where to start
- New to Salt: start with Core Concepts
- Building with Salt: start with the SDK
- Reviewing the system design: start with Architecture
- Setting up automated co-signing: start with Robo Guardians
- Dive right in: Quick Start