FOR

AGENTS

A failsafe onchain harness for autonomous execution

With Sauce, agents write strategies in TypeScript and run them onchain as a single program. Sauce acts as an onchain harness, enabling expressive logic with failsafe execution: every step confirms, or money never moves.

GET STARTED

TALK TO US

Your agent writes the program. Sauce runs it onchain.

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.

SET UP YOUR AGENT

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

Shared token logic compiles for each supported EVM chain and for Solana. Venue and protocol integrations stay specific to each target and its supported execution routes.

strategy.ts
1// written by your agent for this task
2export default program(({ pools, amountIn, minOut }) => {
3  const quotes = pools.map((p) => p.quote(amountIn))
4  const best = max(quotes)
5  require(best.out >= minOut, "slippage")
6  best.pool.swap(amountIn)
7})

Every step confirms, or the execution reverts.

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, that execution reverts.

READ HOW SAUCE EXECUTES

All-or-nothing by design

A failed check reverts every step in that execution, including token transfers and approval changes. Each Sauce execution is atomic on its chain; cross-chain funding, fulfillment, proof and refunds are separate transactions.

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

A private Pot requires its owner’s authorization to run programs. Sign from your own wallet or signer, or from an agent wallet with its own policies. Programs never hold keys or endpoints.

all-or-nothing.ts
1USDC.approve(router, amountIn)
2const out = router.swap(USDC, WETH, amountIn)
3require(out >= minOut, "min output")
4
5// fails here → approve and swap both revert

guardrails.ts
1require(out >= minOut, "min output")
2require(price(WETH) <= maxPrice, "price limit")
3require(USDC.balanceOf(pot) >= reserve, "keep reserve")

by-name.ts
1USDC.transfer(recipient, amount)
2AaveV3.Pool.supply(USDC, amount, pot)
3
4// each name resolves for the target chain at compile time

rehearse.ts
1const preview = await sauce.simulate(program, { pot })
2preview.checks   // every require() evaluated
3
4const tx = await sauce.build(program, { pot })
5console.log(tx)  // unsigned, ready for review

keys.ts
1const tx = await sauce.build(program, { pot })
2
3// only the pot owner can run programs on it
4const signed = await wallet.sign(tx)

Act on the market as it is, not as it was.

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.

SEE EXAMPLE PROGRAMS

Read, compare, branch

Query several contracts, compare what they return, and take the best path, all in one transaction.

Best execution across configured venues

Route a swap through whichever pool quotes best, or split one order across many pools under a single price limit.

Composable steps

Swap, then supply the output to a lending market, measured by the actual amount received rather than an estimate.

Cross-chain follow-through

Publish an intent that moves funds to another chain and runs the next step of the strategy on arrival.

From a single swap to a full strategy.

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.

REQUEST SAUCE ACCESS

Best-execution swaps

Compare configured venues at execution time and fill through the best among them, with dynamic weights and an enforced minimum output.

Market-triggered rebalancing

Automate rebalancing operations and move assets to the chain where they’re needed, with in-flight range adjust and hedging.

Winning liquidation flows

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.

In-flight risk engine for perps

Perform risk calculations during a transaction before committing capital. Open a leveraged position while validating funding rates and direction at execution time.

Programmable treasury ops

Batch payments with netting and FX logic. Inspect balances across multiple assets and compute a paydown or payout order within specified limits.

Commitment-based flows

Submit commitments or proofs within a transaction and validate conditions against them. Privacy depends on the commitment or proof system you integrate; values on a public chain are otherwise visible.

Enforced price limits

Read the price before a swap and after a dry-run call, and abort if slippage exceeds your tolerance. Limits are enforced inside the execution, without relying on private RPCs or protection middleware.

strategy.ts
1import { uniswapV3 } from "@sauce/router";
2
3// written by your agent for this task
4function main(amt: Uint256, min: Uint256) {
5  const q = UniswapV3.QuoterV2;
6  const a = q.quoteExactInputSingle({
7    tokenIn: WETH, tokenOut: USDC, amountIn: amt,
8    fee: 500, sqrtPriceLimitX96: 0 }).amountOut;
9  const b = q.quoteExactInputSingle({
10    tokenIn: WETH, tokenOut: USDC, amountIn: amt,
11    fee: 3000, sqrtPriceLimitX96: 0 }).amountOut;
12  const fee = a >= b ? 500 : 3000;
13  const pool = UniswapV3.Factory
14    .getPool(WETH, USDC, fee);
15  uniswapV3(pool, WETH, USDC, amt, 0, min,
16    ctx.self());
17}

all-or-nothing.ts
1import { uniswapV3 } from "@sauce/router";
2
3function main(pool: Address, amt: Uint256,
4              min: Uint256) {
5  require(pot.WETH >= amt, "not enough WETH");
6  uniswapV3(pool, WETH, USDC, amt, 0, min,
7    ctx.self());
8}
9// a failed check reverts this execution
10// on its chain

guardrails.ts
1import { uniswapV3 } from "@sauce/router";
2
3function main(pool: Address, amt: Uint256,
4              min: Uint256, reserve: Uint256) {
5  const before = pot.USDC;
6  uniswapV3(pool, WETH, USDC, amt, 0, min,
7    ctx.self());
8  require(pot.USDC - before >= min, "min output");
9  require(pot.USDC >= reserve, "keep reserve");
10}

by-name.ts
1function main(to: Address, pay: Uint256,
2              dep: Uint256) {
3  require(pot.USDC >= pay + dep, "not enough");
4  USDC.transfer(to, pay);
5  USDC.approve(AaveV3.Pool, dep);
6  AaveV3.Pool.supply(USDC, dep, ctx.self(), 0);
7}
8// names resolve for the target chain
9// at compile time

rehearse.sh
1# rehearse on a snapshot of current state:
2# no key, nothing is sent
3sauce simulate strategy.sauce.ts \
4  --chain base --owner 0xPotOwner \
5  --args 10000000000000000 23000000 --json
6
7# → returns or the revert reason, plus
8#   transfers, approvals, what's left in the Pot

keys.ts
1import { routes } from "@eco-incorp/sauce";
2
3const { bytecode } = routes
4  .compileSauceProgram("base", source);
5const call = routes.buildSauceEvmCall({
6  pot, engine, program: toHex(bytecode) });
7
8// unsigned { to, data, value }; a private Pot
9// runs only with its owner's authorization
10await walletClient.sendTransaction(call);

Give your agent an onchain harness.

Load the Sauce Skills, rehearse a program against live state, and see what your agent can do when every action is all-or-nothing.

REQUEST SAUCE ACCESS

TALK TO THE TEAM

Give your agent an onchain harness.

Load the Sauce Skills, rehearse a program against live state, and see what your agent can do when every action is all-or-nothing.

REQUEST SAUCE ACCESS

TALK TO THE TEAM

Give your agent an onchain harness.

Load the Sauce Skills, rehearse a program against live state, and see what your agent can do when every action is all-or-nothing.

REQUEST SAUCE ACCESS

TALK TO THE TEAM

Frequently asked questions

What is Sauce?

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.

Why do agents need an onchain harness?

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.

Does my agent need to deploy smart contracts?

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.

Who controls the funds and signatures?

You do. A private Pot requires its owner’s authorization to run programs, and Sauce can hand you an unsigned transaction to sign with your own wallet or signer. Programs never contain keys or endpoints.

How do I get access?

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.

Get email updates on Eco and

everything stablecoins

THANKS FOR SUBSCRIBING

Get email updates on Eco and

everything stablecoins

THANKS FOR SUBSCRIBING

Get email updates on Eco and

everything stablecoins

THANKS FOR SUBSCRIBING