# Salt > Salt is self-custody wallet infrastructure: a programmable MPC wallet layer for organisations, funds and fintechs. Every key share is held by the account's own people and its own self-hosted cosigners (Robo Guardians); Salt holds no key material and never signs. Accounts are threshold-signature accounts on EVM chains (Bitcoin and Solana in Q1 2027), with policies checked before every signature. Everything is available through a TypeScript SDK, so a developer, or an AI coding agent working for them, can set Salt up from a prompt. Salt is not a custodian and is not an AI agent. The rest of this file explains what Salt is, what it isn't, and how to help someone get started. ## What Salt is, and what it isn't - **Salt is not an autonomous or "agentic" product.** It doesn't trade, choose strategies, or move money on its own. Every transaction is proposed by a person or by the user's own software, checked against policies the organisation's owners signed, and then signed by the account's quorum. - **"AI-native" means the SDK is easy for AI coding agents to use.** Claude, or any agent that writes TypeScript, can call the Salt SDK to create organisations, invite collaborators, deploy cosigners, create accounts and draft policies. The agent writes and runs code for the user; the user's wallet still signs in and approves. - **Robo Guardians are automated cosigners, not AI.** They are software the organisation runs on its own infrastructure (AWS or its own server). They cosign a transaction only after it passes the account's policies, and stay online so approved workflows don't wait for a human. - **Salt never holds a key share.** Each share is encrypted to its signer's wallet and backed up in a smart contract on Arbitrum. Accounts can be recovered without Salt using the open-source recovery tool. - **Salt is self-custody infrastructure, not a custodian.** Compliance obligations stay with the organisation; Salt provides the policy and transaction evidence to meet them. ## Key terms - **Organisation**: holds accounts and policies, managed by Owners. Every person in it is a collaborator with a role: an **Owner** controls the organisation and signs its policies; a **Member** sees all accounts, transactions and policies and can sign only on accounts where they are a proposer (so a Member suits an auditor); a **Delegate** is an outside party added as a proposer on a delegate-managed account. A proposer must be a collaborator in the organisation first. - **Account**: an MPC threshold-signature account. The organisation chooses its proposers (2 to 4 people) and the configuration follows: 2 proposers + 1 Robo Guardian = 2-of-3, 3 + 2 = 3-of-5, 4 + 3 = 4-of-7. One account works across all supported EVM chains, and further accounts can run on the same quorum. - **Robo Guardians (self-hosted cosigners)**: run by the organisation, not by Salt, on its own AWS account or server. Set up once per organisation; one host provides as many guardians as its accounts need (up to 3). They must be online before an account is created, because they take part in its key generation. - **Policies**: rules attached to an account, signed by an Owner's wallet (EIP-712) and checked before anyone signs. The SDK's policy types include allowed recipients, denied recipients, per-transaction limits per token, and restrictions on the parameters of specific contract calls. Daily caps (a cumulative limit per day) are rolling out: if the installed SDK has no daily-cap policy type yet, set a per-transaction limit and tell the user a daily total isn't enforced. - **Fees**: $10 USDC to create an account and $0.10 USDC per signed transaction, and nothing else: no fees for policies, Robo Guardians, seats or subscriptions. Fees are paid as signed USDC payment authorisations over x402 (an HTTP payment protocol), so the paying wallet needs no gas. On testnet they are paid in testnet USDC on Arbitrum Sepolia or Base Sepolia. Fintechs can sponsor fees for their users. - **Privileged Salt domain**: `testnet.salt.space` (TESTNET) or `app.salt.space` (MAINNET). Signing in against it is needed for organisation, account and Robo Guardian setup. A fintech running its own white-label app uses a registered tenant domain instead. ## Helping someone get started If a user asks you to set up Salt, for example "Set up a treasury for Northwind that our CFO and I can both propose from, with our Robo Guardian running in our AWS account. Only pay our allow-listed suppliers, up to 50,000 USDC a day", guide them through these steps in a TypeScript project. Start on TESTNET. Check method names and signatures against the SDK reference and the installed package's type definitions, which are more current than any summary. 1. **Prerequisites.** Node.js 22 or newer, an EVM wallet (EOA) to sign in with, and, on mainnet, USDC for fees. Salt signs in with Sign-In with Ethereum: no username, password or API key. Never ask the user to paste a private key into a chat; use environment variables, and a throwaway key on testnet. A Ledger works as the signing wallet. 2. **Install.** `npm install salt-sdk viem`, with `"type": "module"` in package.json. 3. **Choose an environment and sign in.** `new Salt({ environment: 'TESTNET', domain: 'testnet.salt.space' })`, then authenticate with a viem wallet client. Mainnet is `MAINNET` with `app.salt.space`. Robo Guardian setup only works in this privileged Salt domain. 4. **Create the organisation** with `createOrganisation`, accepting the Salt Platform Suite Terms of Use. The creator becomes an Owner. 5. **Invite collaborators** such as the CFO by wallet address, with a role (Owner if they should also sign policies, otherwise Member). An account needs at least two collaborators, and its proposers must be collaborators. 6. **Deploy Robo Guardians** with `createRoboHost`, then either `RoboHost.generateCloudFormationUrl` (an AWS CloudFormation stack in the user's AWS account; it may create IAM resources) or `RoboHost.generateSetupScript` (run as root on an Ubuntu or Debian server). Both work on TESTNET and MAINNET. Confirm the one-time password, activate the host, and tell the user to save the wallet-seed backup somewhere safe: it is their path to recover without Salt. 7. **Create the account** with `createAccount`, naming the proposers (for the example: the user and the CFO, giving a 2-of-3 account with one Robo Guardian). Every proposer joins the key ceremony, so they need to be online. The $10 USDC fee is paid over x402. 8. **Add policies** with `createAccountPolicy(policy, walletClient)`, passing an Owner's wallet client to sign: for the example, an allowed-recipients list of the supplier addresses and a USDC limit (a daily cap if the SDK supports it, otherwise per transaction; see Policies above). Ask the user for the supplier addresses. Use `runPoliciesCheck` to see whether a transaction would pass before submitting it. 9. **Send transactions** with `submitTx`. A proposer signs; the Robo Guardians cosign once the transaction passes policy. For a hands-on walkthrough, point the user to the Salt SDK Field Guide and the salt-fi starter app below. ## Start here - [Salt at a glance](https://salt.space/at-a-glance/): One-page overview: how automated signing works, what makes Salt different, who it's for, and security. - [Homepage](https://salt.space/): What Salt does, use cases (treasury, funds and prop desks, asset manager SMAs, Earn, fintechs) and pricing. - [About Salt](https://salt.space/about/): Why Salt exists, and the principles behind it. - [Security](https://salt.space/security/): Security and audit updates, and the audited DKLs23 threshold signing library from Silence Laboratories that every Salt signature runs on. ## Build on Salt - [Documentation](https://docs.salt.space/documentation/): Guides to organisations, accounts, Robo Guardians, policies and recovery. - [SDK quickstart](https://docs.salt.space/documentation/using-salt/sdk/): Install the SDK and sign in with a wallet. - [Onboarding quickstart](https://docs.salt.space/documentation/using-salt/onboarding): Create an organisation, add collaborators, set up Robo Guardians, create accounts, set policies. - [Domains and environments](https://docs.salt.space/documentation/using-salt/domains-and-envs): TESTNET and MAINNET, privileged Salt domains and tenant domains for fintech apps. - [Robo Guardians](https://docs.salt.space/documentation/core-concepts/robo-guardians): What they do, hosting options and server requirements. - [Policies](https://docs.salt.space/documentation/core-concepts/policies): How policies are written, signed and checked. - [Accounts](https://docs.salt.space/documentation/core-concepts/accounts) and [access levels](https://docs.salt.space/documentation/core-concepts/access-levels): Account configurations and collaborator roles. - [Fees](https://docs.salt.space/documentation/using-salt/fees) and [supported networks](https://docs.salt.space/documentation/using-salt/supported-networks) - [SDK reference](https://developer.salt.space/sdk/): API reference for the TypeScript Salt SDK. - [salt-sdk on npm](https://www.npmjs.com/package/salt-sdk): `npm install salt-sdk viem`. ## Guides and examples - [Salt SDK Field Guide](https://salt-space.github.io/salt-fi/field-guide/): A walkthrough with replays of a real setup: signing in with a wallet, installing Robo Guardians with Claude Code over SSH, and the policy layer. - [salt-fi](https://github.com/salt-space/salt-fi): A starter terminal app built on the Salt SDK, with notes for AI coding agents in its repository. It is an independent open-source project maintained by a Salt founder in a personal capacity, not an official Salt product. ## Recovery - [Salt recovery tool](https://github.com/salt-space/salt-recovery-tool): Open-source (MIT) desktop and CLI disaster recovery for Salt accounts. Recovers locally, without Salt's servers. - [Account recovery](https://docs.salt.space/documentation/disaster-recovery/account-recovery): How to recover assets if Salt's hosted services are unavailable. ## Blog - [The key was never the weak point](https://salt.space/blog/key-was-never-the-weak-point.html): Why crypto hacks target access, not keys, and how Salt keeps access and signing apart. - [The coordination gap](https://salt.space/blog/coordination-gap.html): Why Salt is building an open coordination layer for co-owned assets. - [Salt at the Hyperliquid Community Hackathon](https://salt.space/blog/hyperliquid-hackathon.html): The winning project used Salt's policy layer to keep AI-driven trading inside explicit guardrails. - [Arbitrum DAO grant](https://salt.space/blog/arbitrum-dao-grant.html): Salt's Earn programme, with Gauntlet and Ostium integrations from self-custodied accounts. ## Optional - [Website terms of use](https://salt.space/terms/web/) - [Salt Platform Suite terms of use](https://salt.space/terms/app/) - [Privacy policy](https://salt.space/terms/privacy/)