Plug

Protocols

Docs

Programmable Ethereum Transactions Without Smart Contracts.

381e35

9/27/2026

#company#plugs

Plug speaks every protocol.

Every lending market, every exchange, every vault, every staking and restaking layer, every contract anyone has ever deployed. A Plug can call any of them, and making one first-class takes a single sentence.

That sentence is the whole integration. Write supply an amount of a token to a market once, and the rest comes from it: the form you fill in, the options it offers from your wallet, what every value means, the program it compiles to, the readout of what it did. There is no connector to build, no interface to ship and no SDK to wait on. Other apps list the protocols they support. Plug lists the ones that exist.

Then you compose them, and the game changes.

A Transaction You Can Program

Every transaction ever sent on Ethereum was finished before it ran. Its target, its call and every number in it were fixed the moment you pressed sign. People have been chaining those together for years, into bundles, loops and recipes. That is more transactions. It is not a program.

A Plug is a program. One signature holds:

branches
loops
arithmetic
comparisons
requirements
flash loans with their callback written inline
programs nested inside programs
memory that survives between runs

Every value is read at the instant it runs. The output of one step flows into the next as a live reference, never a number you guessed at when you signed.

What you write goes through a real compiler, the kind that plans control flow, allocates registers, strips dead code and folds away branches that can never be taken. It lands onchain as one program running in your own account. Nothing is deployed for it. There is no contract to write, audit or trust.

Sign It Once. It Runs Forever.

A transaction happens once. A Plug keeps its word.

If my Aave health factor is below 1.35, repay exactly enough debt to bring it back to 1.6, at most once a day.

Signed once, that doesn't expire after it fires. It fires again the next time it's true, at that moment's prices, for as long as the rules you wrote allow. The cadence, the limits and the expiry all live inside the program, under your signature.

Watching it costs almost nothing. Plug records exactly which pieces of chain state your program reads, and checks it again only on a block that changes one of them. Keepers poll. Plug knows.

Sign For Everything That Doesn't Exist Yet

Every signature in crypto names something that already exists: this token, this pool, this market, deployed before you signed and worthless against anything else.

A Plug can sign a description instead. Leave a typed hole where an address goes, write down the tests any candidate has to pass, and sign both. For example: the next Pendle market for this asset, deployed by Pendle's own factory, maturing after the one I'm in. No one has deployed that market yet. Your money is already committed to it.

That is a new kind of thing to be able to sign. A name is a statement about one thing. A hole with tests is a statement about every thing that will ever satisfy it: every market that hasn't launched, every vault a curator hasn't opened, every pool for a pair that doesn't trade yet. Each is one description away from being somewhere your money is already committed to go, safely.

When the thing appears, a solver fills the hole, and each candidate is judged by running your own signed program against it. There is no separate verifier that could drift from what you signed. The dropdown you would have picked from and the hole the solver fills are the same query: one binds when you sign, the other when it runs. A program waiting on a hole doesn't fail. It parks, and wakes on the block the thing it describes is deployed.

Before you sign, the compiler traces every value that comes out of the hole through every branch. It refuses to compile if any of them can reach your money before a test has judged it. A wrong candidate reverts, and a missing one leaves the program waiting. The solver's only power is to stay silent.

You Write The Test. The Market Competes To Pass It.

Every swap you've ever signed froze a route and a tolerance. Every intent system hands you a menu of order types.

A Plug signs the outcome. My USDC balance goes up by at least this much. How it gets there isn't in the signature. Anyone can show up to deliver it, and nobody is trusted: the filler isn't named and the route isn't signed. If the result doesn't pass your test, it never happened.

Routes are programs too, solved at the moment of execution. The fill is split optimally across every kind of liquidity at once: exchanges, lending wrappers, mints, stability modules, Pendle. Before an intent touches a pool at all, it's matched against every other intent in flight. Pairs and rings settle against each other, and every side comes out strictly better than it would going alone.

The same move rebalances a portfolio, refinances a loan or rolls a position. You state what has to be true afterward, and the market does the rest.

An Exchange, Not A Router

A router takes your order and goes shopping for it. Plug is an exchange.

Orders and liquidity are both programs, and every block they're matched in one solve:

orders against each other
what's left against every maker program standing
the remainder against the pools

A market maker's curve is a signed program like any other, with its own rate, caps, floors and expiry. The best of every curve standing is the fair price. No feed declares it. The solve discovers it.

Every order is a live function of chain state, cleared once a block, so there's no race left to win. Nobody cancels and replaces faster than you, because nobody cancels or replaces at all.

Every Order Type Is A Program

Stop, trailing stop, pegged, iceberg: every order type an exchange has ever listed is a special case of one thing, the program.

The program also goes where no order book can. Your own risk and the market can sit in the same order:

Unwind my loop when my health factor crosses 1.2 and ETH is above $3,000.

Quote my idle ETH around the market at this spread, and pull it the moment my loan needs it back.

Any balance sheet can stand in the market on its own terms.

Nothing To Trust. Nothing To Revoke.

Automation has always meant handing someone permission to act as you, indefinitely, and hoping they behave. Stop using it, and the permission stays.

In Plug, the signature is the permission. Your account runs exactly the program you signed and nothing else:

no standing approvals
no operator key
no admin
no upgrade anyone but you can make

Approvals are sized to the step that uses them and reset to zero after it. Anything that lands in your account goes back to your wallet before the transaction ends.

It works however you hold your keys: your own wallet through EIP-7702, a plain account, or a Safe.

Rules Of Approval Live In The Strategy

A treasury's rules have always lived in the wallet: one threshold for everything it ever does. In Plug they live in the strategy.

Move the treasury: two of these three say yes. Harvest the rewards: nobody has to.

The quorum is counted inside the transaction, on the block it lands. Every amount is worked out at that moment, instead of being frozen when the first signer clicked. A quorum signs a standing program once, and it keeps executing for the treasury at live prices.

An agent gets the same treatment: a lane, not a key. Each agent runs its own bounded plug. You can revise it in an afternoon, and it's gone when it lapses. Nothing is deployed for it.

One Send

Run a program now and there's nothing extra to sign. Your wallet sends the program itself, in one confirmation, even from wallets that can't batch.

Everything the program needs is worked out from the program:

the tokens it pulls from your wallet
the approvals each step uses
each protocol's own authorizations

Your first plug creates your account on the way, funded in ETH, and whatever isn't used comes back.

Run It In The Future

A simulator tells you whether a transaction will succeed. Plug runs your strategy through every future you care about before you commit to any of them.

As you type, every step runs against your real wallet and shows its value inline. The branch that isn't taken today runs too, so you see what the else would do right now. A step waiting on a maturity date a year out runs on that day: Plug moves the chain forward to it and shows you what your program does when it gets there. Pin any value, like ETH at $1,500 or a health factor of 1.1, and every step downstream recomputes in the world you described. When something would fail, you see which step, the protocol's reason in plain words, and every value before it intact.

Project Anything

The compiler doubles as a way to read anything onchain.

Any value onchain comes back before a thing is signed, and so does any value you can compute from those values:

your liquidation price
what closing a position would return right now
the yield on a strategy you haven't run
the exact debt a loop would carry after its third turn

Wire the reads and the math together, and the answer is projected live. You can run it as your own wallet, or as any wallet on earth without its owner's signature. On a chain where Plug hasn't been deployed yet, Plug deploys itself into the simulation and runs anyway.

Everyone else shows you a dashboard somebody decided to build. Plug projects whatever you can think to ask.

Write It The Way You'd Say It

Type 1.5 USDC and Plug compiles 1.5 USDC, even when which token it is won't be known until the block it runs. Type if the APY is above 2 and it means two percent. Say repay all and the debt closes to the wei. If your wallet can't cover it, a sentence tells you exactly how much stays open.

Every value carries what it means: a token, a market, a position, an amount on its own scale. The compiler checks meaning, handles the units, and only offers you choices that will work. You never touch a wei. Everyone else hands you raw integers and wishes you luck.

A Language With Time In It

Plug is a programming language, and it's the first transaction language with time built into its meaning.

Every value has a defined moment it becomes fixed:

when you sign
when it executes
when it's filled
when an auction checks it

You can see which, and the compiler holds you to it.

The app, your editor and your agents all talk to the same compiler, so a half-finished program in any of them still gets real answers.

Doing And Describing

Every action in Plug reads two ways, and Plug knows which one you mean.

When you're acting now, it offers what you hold: your balances, your positions, the amount you can actually spend. When you're describing a strategy that hasn't run yet, it offers the whole universe of valid targets, priced and yielding. That includes the ones you'll only hold because an earlier step handed them to you. The same sentence is a button when you want to press it and a blueprint when you want to build with it.

Every Token Knows What It Can Do

Click any token and Plug tells you everything you can do with it, across every protocol, with the token already filled in. You get one row per verb, like supply, stake, lend or deposit, with every protocol that offers it behind that row.

Click a position and its market is already bound in every action it supports, including the ones that only make sense because of what you hold: withdraw what you supplied, repay what you borrowed, repay it from the supply itself.

A portfolio app shows you what you have. Plug shows you what you can do with it, and one click later it's a program.

A Strategy With A Memory

The chain has no memory. It knows what everything is worth right now and nothing about yesterday, which is why every strategy that asks how much did this change has needed a server someone else runs.

A Plug remembers for itself. It writes its own history onchain, one run at a time: the price it entered at, the yield it measured last week, a moving average it has been building for a month. That history belongs to your wallet, to one plug, or to one exact version of it, as you choose. Assets whose defining number was only ever computed offchain become things you can automate.

Plugs Are Functions

Build a piece of logic once and never build it again.

A plug can take inputs, return an answer and be used inside any other plug. A function that turns a target health factor into a target debt becomes a part in every strategy that needs one, and a hundred plugs can point at the same function. Composing with Mirror doesn't cost you anything: the functions are flattened into one program, so everything a single plug can do, a stack of them does too.

Plugs Talk To Each Other

Run a loop, a stop, a take-profit and a liquidity guard as separate plugs on one account, and they move as one.

They share memory. When one gets out, the rest know on the same block, like a flock. One plug's answer can fill another's input, so a borrow-rate read can set the threshold a refinance acts on.

Every No-Code Protocol Is One Plug

A whole category of companies exists to ship one strategy behind a button: rebalancers, stop-losses, leverage loops, refinancers. Each one is a team and a roadmap. On Plug, each one is a plug, readable and forkable and yours in a minute.

That is the floor. All it takes is a plug to get behavior this industry has never seen:

a loan that refinances itself into a market launched after you signed
a treasury that trades on its quorum's standing orders
a position that keeps its own price history onchain and acts on the average
a strategy built from functions other people wrote, each one readable

Yours To Run. Anyone's To Fork.

A plug compiles to whoever runs it. Yourself means you while you use it and whoever forks it after, so every strategy anyone shares is instantly reusable.

Open someone else's plug and it reads as a recipe with your balances filled in. Change anything and it forks to you. Every plug embeds live anywhere, like every plug in this post. Strategies stop being settings trapped inside an app. They are software anyone can read, run and build on.

Exact, On The Block It Changes

A program is only as good as what it knows.

Plug knows your health factor as the number Aave's own contract computes, to the wei, on the block it changes. Every protocol's math is ported exactly and proven against mainnet.
Liquidation prices are rebuilt from the oracle's own inputs.
Every storage slot every block writes is streamed as it lands, so nothing is polled.
Every wei of ETH is accounted for, including the ones that move deep inside other contracts.
Paste any address and its full history is built from its first transaction.
A token has a price on the block its first pool appears, and liquidity that isn't real can't fake its way into a route.

Built For Agents

An agent can't hallucinate a Plug. Every option it can pick is one the compiler accepts, every connection it draws is checked by meaning, and nothing it builds counts as done until it compiles against your real wallet. It builds in your workspace through the same edits you make, each one undoable. It can write code to assemble a seventy-step program in one pass. It can never sign. You do.

The whole compiler is open. Send it a half-finished program with no key and no account, and it sends back the value of every step.

It Goes Where You Go

The machine underneath is portable. Your account has the same address on every chain, and your plugs move with you: to every EVM chain, and to wherever there's a chain worth programming.

Every Protocol

Everyone else is building an interface over a menu. We built the language, the compiler, the solver and the state engine underneath all of it, so that anything onchain can be programmed by anyone who can write a sentence.

Every protocol. Signed once. Running forever. No smart contract to write, and nobody holding your key.