Plug
Programmable Ethereum Transactions Without Smart Contracts.
Programmable Ethereum Transactions Without Smart Contracts.
381e35
2/8/2026
#company
Swap in one place, approve the output, supply it in another, set up a position. Four separate transactions for a single strategy. Then check back every few hours to make sure nothing has drifted, or hand your keys to a centralized bot and hope for the best.
Every approach to DeFi automation forces the same choice: power without simplicity, or simplicity without trust.
Plug eliminates the choice. Today we are live in Alpha.
The Standard Transaction
Every interaction with every protocol on every EVM chain reduces to one simple specification: a transaction. Six fields, each locked the moment you sign.
The
to field accepts a single address. Your transaction talks to one contract. A strategy that touches two protocols requires two separate transactions, signed independently, confirmed independently, with nothing connecting them.data encodes your function call. Method, parameters, amounts. All of it built against state that existed the moment you pressed sign. One second later the market moves and everything baked into that calldata is stale. The amounts are wrong. The expected output has shifted. The opportunity may already be gone.This is why transactions revert so often. You sign against one version of the world, the chain executes against another. Every hardcoded value is a bet that nothing changes between signing and confirmation:
value is the amount of native token (ETH) transferred. A raw integer of wei hardcoded into the transaction. You cannot reference your current balance, compute a percentage, or react to the output of a previous step. You commit to an exact number at signing time and hope it still makes sense when the transaction confirms. This single constraint has broken more protocol integrations than any bug.nonce enforces strict ordering. Transaction 43 cannot execute until 42 confirms. A single stuck transaction blocks every transaction behind it. No parallelism. No reordering. No recovery without manual intervention.chainId binds you to one network. Cross-chain strategies require separate transactions, separate signing contexts, and manual coordination of state between them.gasLimit is a resource estimate you commit to before execution. The network determines the actual cost. You're budgeting for something unknowable until the transaction lands, with no control over it once signed.Everything frustrating about DeFi UX traces back to these six fields. Want to swap and supply the output as collateral? Two transactions. The first confirms, you copy the output, build the second around it, sign again. If the value moved between them, your amounts are wrong. If gas spikes, the second sits in the mempool while the output from the first depreciates.
Want to automate that? Two options:
- Write a smart contract that encodes your logic onchain. Accept development time, an audit, deployment costs, and a system you can never update without migrating state.
- Or delegate signing authority to an offchain operator and trust that they execute honestly.
One path gives you power without simplicity. The other gives you simplicity without trust.
What Plug Does
A Plug is a set of actions wired together that execute as one atomic transaction. What used to be four or five separate transactions for a basic position becomes a single signed intent you can reuse whenever you like.
The interface lets you construct these visually. No code. No scripts. Declarative sentences that describe what happens when it runs:
Building a Plug should feel like explaining something to someone who already knows how to do it. Not fighting dropdown menus. Not hunting for contract addresses. Simple statements of what you want and the system figures out the rest.
Readable Transactions
Previous composability solutions made you read calldata, learn a domain-specific language, or settle for centralized automation with zero transparency. Plug takes the opposite approach. Every action reads like a sentence:
When you can read your transaction, you catch mistakes before they cost you. When someone shares a Plug, you understand what it does immediately. No reverse-engineering. No trust-me-bro. Just read it.
Plugs are validated and executed onchain with no central intermediaries. The sentence you read is the intent that executes onchain.
Referencing Transaction Values with Coils
Bundling actions into a single transaction is useful, but if you can't pipe the output of one step into the input of the next, you're running 
Multicall with extra steps.
Coils wire your actions together. The value returned from one function call flows directly into the next. The collateral you supplied becomes the reference for the following action. No manual tracking. No copy-pasting values between steps.
No stale values. No hardcoded amount that drifts by the time the transaction lands. State threads through every step — when you reference "the amount I just swapped" or "the position I just opened," it's always current.
You do not build a transaction with hardcoded amounts unless those amounts are truly static. Plugs operate as perpetual intents that read and build upon current blockchain state at execution time. Every value is calculated live and carried through each step automatically.
Consider a scenario where you want to transfer 50% of your balance. In typical systems, you have two options:
- Hardcode 50% of the balance you held at signing time.
- Delegate transfer rights to a centralized operator who can steal your funds but tends to be honest.
With Plug, you reference your balance at execution time, calculate 50% of it, and use that as the transfer amount. Every run transfers 50% of your current balance, regardless of how it has changed since you signed.
Arbitrary Logic and Branches
With Coils handling state, the core protocol actions work. Swap, supply, borrow, withdraw. The DeFi verbs. But the moment you build real strategies on top of them, the gaps surface.
You can't express "swap my if the price is above $2,000" with protocol actions alone. You can't say "rebalance every 24 hours" or "only borrow up to 60% of my limit."
Plug includes math operations, boolean comparisons, time-based conditions, and string manipulation — all expressed as the same readable sentences everything else uses:
This is what separates Plug from a transaction bundler. A bundler executes a list. Plug executes logic. The difference matters the moment your strategy needs to react to market conditions, which is immediately and always.
But primitives alone don't change outcomes. You can compare two numbers. You can check the time. Without control flow, those are observations with no consequences.
Branches split your Plug into paths. A condition evaluates to true or false, and each path executes accordingly. What was a linear sequence of actions becomes the codification of any behavior you can imagine:
Every piece of onchain state feeds the next. Coils wire outputs forward. Arbitrary logic computes and compares. Branches decide what happens. The full set of primitives you'd expect from a programming language, expressed as sentences anyone can read, signed into a trustless intent no one can falsify.
Contextual Inputs
How do you know what a valid input is? If you're entering an amount, where is your current balance? The exchange rate? The protocol limits? This is where consumer-grade DeFi automation stops. Every input is the same generic text field. Figure it out yourself.
Every input in Plug is context-aware. When you're swapping, you see your balance, the current rate, the expected output. When you're supplying collateral, you see your health factor, your positions, what this action will change:
There is no AI or magic. Just good design and a system that knows what you're doing. When you integrate Plug's API into your own app, you get all of this for free.
Real-Time Onchain Data
A Plug that checks your health factor against a threshold is useless if the health factor is stale. A price-gated strategy doesn't work if the price is 30 seconds behind the market.
Most platforms solve this by building a massive network of oracles and offchain data providers, pulling data from multiple sources, aggregating it, and hoping it's fresh by the time the transaction executes.
Plug doesn't need this. Coils and arbitrary logic run onchain while the transaction itself is executing. Every piece of data used in a Plug is retrieved, validated, and consumed onchain without a call to an external API. A Plug that says "swap if the price is above $2,000" checks that condition at the moment it lands. If constraints are invalid, the transaction never executes.
No global clock polling your intent. No cron job. Every upstream state change propagates downstream immediately.
So why invest in real-time data at all? Because the builder experience demands it. Token prices across every pair. Gas costs across every chain. Supply rates, borrow rates, funding rates. Utilization, liquidity indexes, debt ceilings, borrow caps, TVL, pool liquidity. Every data point you need to make an informed decision, live while you build:
Cross-Chain User State
Global state tells you what the market is doing. User state tells you what you can do about it.
Every position you hold — across every chain, across every protocol — is indexed and kept current. Wallet balances, supplied collateral, outstanding debt, staked positions, LP shares. When your health factor shifts because moved, Plug already knows. When you receive tokens on Base, your Plugs on Ethereum that reference your total balance update immediately.
There are no balance checks or hidden RPC calls when you open the app. User positions are tracked the same way global state is tracked: continuously, across every chain, propagated the moment anything upstream changes.
Protocol positions are handled natively. Aave collateral, Lido stakes, liquidity positions. Not as generic token balances but as typed, protocol-aware positions with the metadata that matters: health factors, accrued rewards, claimable yields, position limits. The context your Plug needs to make decisions is already computed and waiting.
Where We Are
Everything above is live and functional. Composable transactions, state threading, arbitrary logic, branches, contextual inputs, real-time data, cross-chain state. You can build, test, and simulate Plugs right now that would have taken days and custom smart contracts to achieve before.
The tradeoff between power and trust has never been fundamental. It was a design failure. Readable intents that anyone can verify. Arbitrary logic that composes without code. State that threads through every step, live at execution time, with no centralized operator in the loop. Plug doesn't ask you to choose. You get all of it.
Onchain execution launches in Beta. The Plugs you build today will execute exactly as described when it goes live. Between now and then — more protocols, more actions, more chains. Alpha proves the abstractions work. Beta makes them disappear.