Introducing the Eco Sauce SDK: Write the Rules for How Money Moves
Sauce SDK turns blockchain transactions into fully executing programs, for developers and agents that need atomic, failsafe execution for onchain money movement.
Sauce SDK turns blockchain transactions into fully executing programs—for developers and agents that need atomic, failsafe execution for onchain money movement.
At Eco, we’ve spent years building toward the promise of programmable money. And we’ve always engineered around this persistent paradox: We have smart contracts, but dumb transactions. Smart contracts and DeFi give us programmable markets, but the token and transaction are what make money programmable.
Sauce—a new, agent-native framework for programming onchain money movement—is our answer to the programmable money paradox.
How We Got Here: The Fundamental Tradeoff Sauce Solves
Building technology for onchain money movement is uniquely challenging. You have to learn unfamiliar development patterns, and you’re constantly building infrastructure to track blockchain state, stream data, connect to new markets, add safety checks, and more. It never really ends.
Suppose you’re building an app for users to buy SpaceX shares at the best available price onchain. You need a solution to identify markets, check their prices, simulate the expected outcome, route funds, and retry on failure. Building and updating those workflows usually means custom smart contracts and the infrastructure to run them.
But no matter how good you are at all that, you’re still facing a fundamental tradeoff: use smart contracts with static logic, or add latency with offchain infrastructure that’s easy to update.
The first option can respond to market conditions during execution but only via preset rules; changing those rules brings additional development, review and deployment work. The second option makes the code easy to update, but it can undermine execution quality, especially when moving large amounts.
Both are fundamental flaws for us. Most of Eco’s customers navigate onchain markets using stablecoins. They need superior price control, at institutional scale, with the flexibility to change strategies quickly. To give them that, we need perfect execution against real-time market conditions, and we need to ship new strategies and routing behavior quickly without standing up a new contract every time.
So we designed Sauce around these two principles: make decisions within the transaction, and make the instructions easy to change. Sauce lets a single onchain transaction carry its own program and run it at the moment of execution. Sauce eliminates the fundamental tradeoff between onchain contracts and offchain infrastructure—and now we’re making it available to you too.
Introducing Sauce SDK: Delete the Backend
Today, we’re launching Sauce SDK, giving developers and agents access to the programmable transaction engine behind Eco’s real-time routing.
With Sauce SDK, you write transaction logic in TypeScript, and it runs inside the transaction itself—your program reads live state across any number of markets, branches on what it finds, and either delivers the exact outcome you defined or reverts entirely. There’s no contract to build or deploy for each workflow. You write the logic and send it.
Because the decision happens at execution time rather than at signing time, best execution becomes a property of the program. A Sauce program can check several venues and take the winner in the same transaction that settles. It can enforce a minimum output and refuse to settle below it.
main() function in SauceScript, and the compiler turns it into compact bytecode that travels with the transaction and runs once, onchain, against the live state the network sees at that moment. The program can read from many contracts, compare results, loop, and pass the output of one call into the next. Then it either commits as a whole or reverts as a whole.The Sauce SDK supports Ethereum, Base, Arc, and Solana at launch. It ships with built-in support for hundreds of onchain markets and protocols, a library of ready-to-run recipes, and a suite of Skills that let AI coding assistants build with Sauce SDK directly.
After using Sauce in production ourselves, we've seen what it can do. Developers ship faster and keep tighter control over how money moves. We believe the ability to program a transaction's outcome and have it enforced at execution should be a basic building block of onchain development. So we've made it one.
The Upshot: Failsafe Execution for Agents and Institutions
The same property that makes Sauce useful for developers—an outcome defined in advance and enforced at execution—is what makes it valuable to anyone moving money at scale.
An onchain harness for agents
Agents are good at deciding what to do. The risk lies in what happens when their picture of the world is wrong—a stale price, a mistaken assumption, a misread balance—and in translating offchain decision logic into failsafe onchain execution logic. With Sauce, an agent expresses its intent as a program with hard boundaries set by its operator, covering how much it can spend, what it must receive, and where funds are allowed to go. The program checks those conditions against reality at the moment of execution. If they hold, the transaction completes. If they don't, nothing moves.
That turns agent safety from monitoring into simulation and construction. An agent can act fast on market conditions, but it can't act outside its terms. And with Sauce Skills, the same assistants that power those agents can author Sauce programs directly.
Programmable requirements for institutional money movement
Institutions don't think in transactions. They think in capital requirements and operating models: a maximum all-in cost, a minimum delivered amount, approved counterparties and destinations, timing and compliance constraints. Sauce lets teams write those requirements directly into the transaction and enforce them against live conditions as it executes.
A treasury team can rebalance only when conversion costs fall below a threshold. A payments platform can settle a stablecoin payment only if the recipient receives the full amount. Every operation is all-or-nothing, so there are no partial states to reconcile and no outcome that falls outside policy. Because programs are verifiable from source, they fit naturally into internal review and controls.
What's in the Sauce SDK
What ships with the SDK today:
- TypeScript, not a specialized blockchain language. Write transaction logic in one of the world's most widely used languages. If you'd rather not write SauceScript at all, the built-in token, swap, and deposit builders generate programs for you.
- Hundreds of onchain markets and protocols, out of the box. Global namespace with typed interfaces and per-chain deployment data for widely used onchain protocols, plus a canonical chain registry, so you build against the ecosystem you already know.
- Ready-to-run recipes. Production patterns you can read, run, and adapt, including best-pool swaps, order splitting, CCTP split transfers, and settlement with a guaranteed minimum output.
- Skills for AI coding assistants. Per-protocol instruction files that let tools like Claude Code and Cursor write correct Sauce programs from the start.
- EVM chains and Solana. Ethereum, Base, Arc, and Solana at launch, with more chains coming. The same SauceScript program also runs on EVM chains and Solana, so you write your logic once for both.
- Verifiable by design. You can recompile any program from its source and byte-compare it against what's executing, so you never have to trust its contents.
We anticipate expanding full Skills support to more chains very soon.
Start Building
Sauce already powers the swap routing engine behind Eco Routes API. Our team uses it to compare markets, split larger orders, and enforce minimum received amounts. New routing and rebalancing logic ships as programs we can write, test, and update without a new custom contract deployment for each workflow. That lets us improve routing more quickly while enforcing customer requirements during execution.
But that’s only a small slice of what you can do with Sauce. We’re making Sauce available through the SDK, so your team can build with the same tools we use in production, adapted to your use case.
The Sauce SDK is available today. Install the package, run a recipe, and have your first program executing onchain in minutes.
Getting started takes one install:
npm install @eco-incorp/sauceTo learn more about Sauce, including partnerships and enterprise use cases, visit eco.com/sauce.
About Eco
Eco connects digital asset markets through stablecoins. Developers and enterprises use a single integration to program money movement across blockchains, tokenization platforms, and institutional liquidity venues, with real-time routing and pricing intelligence. Whether for trading, treasury, or payment flows, Eco delivers superior price control and all-or-nothing execution against live market conditions and customer-defined requirements.