Sauce Skills teach agents SauceScript, a checked subset of TypeScript, along with the tokens, protocols, and patterns each chain offers. Your agent writes a fresh program for each task, compiles it to bytecode, and runs it in a single transaction—without needing to deploy a smart contract.
Arbitrary logic, in a language agents already know
Conditions, loops, reads, and checks, written in TypeScript and executed as written onchain. It’s a real program, not a batch of calls.
Skills built for agents
Load Sauce Skills into Claude Code, Cursor, Codex, and more, or serve them over the Sauce MCP server to agents with no files on disk.
One program, many chains
The same file compiles for each supported EVM chain and for Solana. One interface to program across multiple chain environments.
Agents are flexible, and that’s the point. Sauce makes their actions safe to execute. Every check an agent writes is enforced onchain, inside the same transaction as the money movement. If a condition fails, the whole program reverts.
All-or-nothing by design
A failed check reverts every step, including token transfers and approval changes. There’s no half-finished state for an agent or developer to clean up.
Guardrails written into the program
Minimum outputs, price limits, and balance checks live in the code that moves the money, so they hold no matter what the agent intended.
Tokens and protocols by name
Programs call USDC.transfer(…) or AaveV3.Pool directly. The compiler resolves each name for the target chain, so agents never invent an address.
Rehearse before you send
Simulate any program against live chain state before a single signature, then print the unsigned transaction for review.
You keep the keys
Each execution contract belongs to one owner, and only that owner can run programs on it. Sign from your own wallet or signer, or from an agent wallet with its own policies. Programs never hold keys or endpoints.
Most onchain actions lock in their route when they’re signed, and markets move before they land. A Sauce program reads live state in the same transaction it executes, so your agent’s decision is made against current prices and balances, at the moment it matters.
read: pool A · pool B take: best
Read, compare, branch
Query several contracts, compare what they return, and take the best path, all in one transaction.
split: many pools under: one price limit
Best execution across venues
Route a swap through whichever pool quotes best, or split one order across many pools under a single price limit.
supply: actual amount received
Composable steps
Swap, then supply the output to a lending market, measured by the actual amount received rather than an estimate.
publish: intent on arrival: next step
Cross-chain follow-through
Publish an intent that moves funds to another chain and runs the next step of the strategy on arrival.
Give an agent a goal and a set of limits. Sauce turns its plan into one program that either completes within those limits or doesn’t run at all.
Compare venues at execution time and fill through the best set of them, with dynamic weights and a guaranteed minimum output.
Automate rebalancing operations and move assets to the chain where they’re needed, with in-flight range adjust and hedging.
Pull position health live, evaluate liquidation bonus vs swap route vs gas cost in real time, dynamically pick best collateral to seize, re-validate profitability after each step.
Perform risk calculations during a transaction before committing capital. Open a leveraged position while validating funding rates and direction at execution time.
Batch payments w/ netting and fx logic. Inspect balances across multiple assets, compute optimal paydown/payout order within specified limits.
Use bitwise ops to encrypt or mask certain values, submit commitments/proofs within tx, validate conditions without revealing how they were derived.
Self-defensive swaps, without relying on private RPCs or protection middleware. Can pull price before swap, after dry-run call, detect hostile slippage, abort if exceeds tolerance.
Sauce is Eco’s programmable-transaction runtime for EVM chains and Solana. Programs are written in SauceScript, a checked subset of TypeScript, compiled to bytecode, and executed atomically in a single transaction.
Agents reason flexibly, but onchain actions are irreversible. Sauce puts every guardrail in the program itself and enforces it in the same transaction as the money movement, so an agent’s action either completes within its limits or doesn’t happen.
Not with Sauce. Programs compile to bytecode and run through your Pot, an account that belongs to you. There’s no contract to write, audit, or deploy for each strategy.
You do. Only a Pot’s owner can run programs on it, and Sauce can hand you an unsigned transaction to sign with your own wallet or signer. Programs never contain keys or endpoints.
Sauce v1 is currently available to select partners on request. Request access to start building, or use the Routes API today for cross-chain stablecoin transfers.
