

<AlphaConfetti></AlphaConfetti>

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:

<AlphaStandardTransaction></AlphaStandardTransaction>

`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:

1. 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.
2. 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:

<AlphaPlugs></AlphaPlugs>

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](#what-plug-does) reads like a sentence:

<AlphaSentence></AlphaSentence>

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](#what-plug-does) 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](https://www.multicall3.com/).

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.

<AlphaCoils></AlphaCoils>

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](#referencing-transaction-values-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 <Token>ETH</Token> 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:

<AlphaArbitraryLogic></AlphaArbitraryLogic>

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:

<AlphaBranches></AlphaBranches>

Every piece of onchain state feeds the next. [Coils](#referencing-transaction-values-with-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:

<AlphaOptions></AlphaOptions>

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](#referencing-transaction-values-with-coils) and [arbitrary logic](#arbitrary-logic-and-branches) 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:

<AlphaRealtime></AlphaRealtime>

### 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 <Token>ETH</Token> moved, Plug already knows. When you receive tokens on Base, your Plugs on Ethereum that reference your total balance update immediately.

<AlphaUserState></AlphaUserState>

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.

[Start building now.](https://plug.to/app)


Compose complex DeFi strategies as readable intents with arbitrary logic and real-time data. No smart contracts. No centralized operators. No code....

Programmable Ethereum Transactions Without Smart Contracts.



<LandscapeTrap></LandscapeTrap>

When you spend your time building in crypto, it is not uncommon to tune out the outside world. Then you surface only to realize everything has shifted and the people you once knew are long gone.

It's not just you. That's happening right now while I write this. Something happened. Prices are down; why? Couldn't tell you.

Staying up to date with everything in crypto is impossible. Staying up to date with everyone in your network is its own full-time job. So, as we prepared to launch [Plug](https://plug.to), I found my team needing answers that I had not prepared and were not readily available.

As a builder in the web3 industry, it is easy to accumulate years of tribal knowledge. Yet, there was not a single place I could send them to navigate the landscape.

- Who are all the new entrants into the industry?
- What vertical does each company occupy?
- What companies would be great to work with?
- What integrations would be ideal to have?
- Who can we partner with?
- Where are the relationships not visible in public?
- What investors are active in this sector?

Those are the questions I set out to answer. Below is a curated output from my efforts.

## The Directory

This database covers 500+ web3 and blockchain startups across DeFi, infrastructure, L1/L2 protocols, wallets, and more. Each entry maps their connections to VCs, auditors, technology providers, and key people. Use it for business development, competitive analysis, market research, or just figuring out who's actually building what in the ecosystem.

> _This data is updated regularly. If your company should be included, or if you spot an error, reach out to [@plugdotteeoh](https://twitter.com/plugdotteeoh) and let us know._

<Landscape></Landscape>

Understanding who is out there is the first step, and it helped my team immediately. Put a little information in front of someone and things start to happen like magic.

But execution, is where it gets hard. Because of this, you see a lot of marketing devoid of any human touch as Claude becomes the Senior Editor on every post pushed to /blog. The words have been distilled into technical jargon and deciphering the meaning is futile. How did we get here...?

## The Connections

Knowing who you're talking to is one piece of this puzzle, but knowing what to say is the other.

How can you have an impact on the market if you don't study what has and hasn't worked? So, armed with the data we need, let's dig deeper and reach a level of understanding few others have.

<LandscapeConnections></LandscapeConnections>

As you explore, one thing becomes obvious: **We are all building the same thing.** Many of us have visions far more aligned than you would realize at first glance.

With just a few minutes of looking, you can answer the questions that matter:

- Would this company be a good user of my technical stack?
- Do we share social positioning?
- Are there connections to the people that I already have?

The list goes on. The data can't tell you what to do, but it gives you a magnifying glass on everyone who carries weight in your orbit. First step done.

## The Archetypes

Just one moment, though. Give your team this data raw and you will find yourself without effective conclusions and something you can't be very confident in. The picture is far bigger than a list of names, but it is exceptionally easy to forget that.

To avoid this, for our team at [Plug](https://plug.to) the next step was to invert the relationships. [Our go-to-market depended on proving things fundamentally valuable to the market](https://plug.to/posts/looping-on-aave). We needed to know who was using it, who was building on it, and who was investing in it. We needed to know how to reach those people and how to build relationships with them.

As a concrete example: For us, one pillar of this meant understanding how curators operate in the market. We know their onchain stats. We needed to know who they are and what they think, and we set off to answer that:

<LandscapeArchetype></LandscapeArchetype>

But we quickly noticed a fundamental problem in our thinking. A simple list of who operates in similar areas is not enough. There is no objectively correct view. No arrangement guarantees the best conclusions. Yet, there are better and worse ways to look at the data of the market we all operate in.

The trap most founders, startup teams, and builders fall into is believing that more data means better decisions. It doesn't, not at all unfortunately. You can stare at a spreadsheet of 500 companies and still have no idea who to call first or what plan to enact. The structure tells you what exists. It doesn't tell you what matters or how to act on it.

What moves the needle is understanding how the market talks about itself. The words that surface when people describe their work to each other. The protocols they reference. The auditors they trust. The people whose names keep appearing in cap tables and advisor lists. These patterns reveal the invisible social fabric that determines who gets intros, who gets distribution, and who gets ignored.

## The Language

At this point, we had to stop asking "who is out there" and start asking "what are they clustering around." The first question gave us a list. The second gave us a map. The map is what helped us prioritize, and hopefully it does you as well.

To avoid significant time-sinks that result in directionless discovery, we turn our focus to the social ties of each entity in our map. We understand their prose, service, and objectives so we have everything we need to have a fundamental understanding of where each sector of the market lives:

<LandscapeKeywords></LandscapeKeywords>

With all this available to us, the final step is seeing these patterns in context. Individual keywords tell you what concepts matter. But most of our insight came from seeing how companies within the same vertical cluster around shared language.

## The Clusters

When you look at a category like Yield Aggregators or DEXs, the keywords they share are far from random. They reveal the mental models that define that space. The companies clustered tightly around the same keywords are either direct competitors or natural partners. The outliers using different language are either ahead of the curve or solving a different problem entirely.

There is a very obvious story being told by the way these companies talk about themselves. The story is not always what you expect, but it is always there.

<LandscapeOverlap></LandscapeOverlap>

Finally, we've reached the point where it is easy to get nerd-sniped. There are so many things you could do here. Go add sentiment analysis. Implement social tracking. I considered both of those and many other things as well, but the data is a tool. It's not the work.

If we accumulate a bunch of data and don't know how to use it, what's the point? For Plug, this exercise wasn't academic. We needed to know who we were building for, who we could partner with, and who would amplify our message.

The landscape gave us the map. The connections showed us the paths. The keywords revealed the language. The overlap told us exactly where to start. So, each morning we wake up and work through our graph. But the spreadsheet hasn't sent a single DM. We do.

## Now What?

If you've made it this far, you're probably not casually browsing. You're building something. You're trying to figure out how to navigate a web3 industry that moves too fast, talks too much, and rarely says anything you needed to know. Maybe you're a team member being asked to do way too much. It doesn't matter because the answer is the same for all of us:

**The best partnerships come from shared vocabulary.** Two companies in the same vertical using different language will struggle to collaborate. Two companies in different verticals using the same language will build something incredible together.

Set off and explore your graph. Your network is smaller than you think but more powerful than you realize. Most of the meaningful relationships in crypto are two or three introductions away. The people you already know can get you to anyone. You just have to ask.

The landscape of crypto in 2026 is simultaneously more crowded and more collaborative than ever. There are more companies building, more capital flowing, and more infrastructure emerging. The people doing the building are just waiting for someone to reach out.

[If your list is still small, reach out to me directly](https://twitter.com/nftchance). If your list is big, start with the tight clusters. The companies that speak your language. The ones that will get it immediately. The ones that will be excited to talk to you.


Interactive database of 500 crypto companies, their connections, investors, and shared infrastructure. Searchable, downloadable, and updated regularly....

500+ Crypto Companies Mapped - Who's Building, Who's Connected.



You have the capital. You have strong conviction on price direction. You watch the markets like a hawk and obsess over support and resistance levels. You monitor how the whales are moving and follow their lead. Time and time again, you’re right about your trades, and this time doesn’t feel any different.

<Token>ETH</Token> is setting up. You’ve been analyzing the market and see the trend coming. You’re watching what big money is saying and doing, and they validate your thesis. You’re ready to jump on the opportunity, so you go to open an <Token>ETH</Token> long at 3x leverage. 

Call the direction and you can realize multiplied gains. Miss the mark and you could take a multiplied loss. Where you ultimately land depends on two things: where price goes and the value you capture or lose when you decide to get out. 

You have an exit strategy in mind. You know that timing is everything. But you can’t monitor the charts every second, and the market moves whether you’re there or not.

## Waiting for the Exit Window

You enter the position when <Token>ETH</Token> is at $3,000. No stop loss or take profit. You’ll time it yourself.

Over the next few days, the price gradually climbs: up 5%, 10%, 15%. You step away to hit the gym, make dinner, and spend some quality time with your partner. A few hours away from the charts is fine. When you check your phone again, you see <Token>ETH</Token> spiked to \+25% and quickly reversed back to \+10%. 

<AaveLoopingNoSlTpChart></AaveLoopingNoSlTpChart>

You were right about the upward trend, you just weren’t there to capture the upside. The peak came and went without you and you gave back more than half the move.

## Never Missing the Window Again

But you’re still up 10%. Volatility is expected and your conviction hasn’t changed. Now you just want to ensure you capture the gains if you’re not online to do it yourself. 

You decide to set a take profit limit on your position \+25% above your entry price to automatically bank profits.  
	  
A week later you're up 15%, see a small dip, then watch it run to \+20%. You put your phone down and go to bed satisfied that you're only a few points away from your target. Then you wake up early the next morning and see everyone tweeting about the short squeeze. Overnight, big clusters of short liquidations hit and sent <Token>ETH</Token> climbing: \+25%, 30%, 40%. 

<AaveLoopingFixedTpChart></AaveLoopingFixedTpChart>

Your take profit hit. You captured the gains. Another winning trade complete. But you can't ignore the money left on the table. You called the direction, you just got capped out too early.

## Never Exiting Too Early Again

No ceiling this time, you want to stay in the trend as long as you can. But you’ll set a floor to cap your downside in case you aren’t around when the reversal eventually hits. You know how much can change in a matter of hours, and you admit you can’t always be there to catch it.

You open a 5x leverage <Token>ETH</Token> long at $3,500. No take profit target. Tight stop at \-5%. 

Price climbs 6%, 12%, then pulls back to \+8%. No problem. Then it starts falling again: \+4%, breakeven, \-2%, \-6%. Right through your stop and you're out at a loss. 

<AaveLoopingTightSlChart></AaveLoopingTightSlChart>

You check back later to see the price has recovered and is running up. You were right about the direction, it just took some time, and your tight floor shook you out before you had a chance. You needed more room.

## There’s Always Value Leaking Somewhere

Different trades, different exit strategies, different environments, but the same result:

You’re right about the direction, you’re just not capturing your upside effectively. And no matter what you adjust, there’s always value leaking somewhere. 

You learned and adapted along the way. You tried new ways to secure your wins. Your exit targets made sense to you at the time. But your targets aren’t the problem. 

Any number you set on entry, or at any given moment along the way, can’t anticipate what the market will do next. The market is moving at all times, but your exit targets are static and aren't adjusting with it.

## A Market-Aware Exit Strategy

Imagine you instead set a trailing stop loss to start at a fixed percentage below your entry price, say 10 points below $3,000 for the leveraged <Token>ETH</Token> position.

As the price rises, your trailing stop rises with it, always staying 10 points below the last peak price. But when the price falls, your trailing stop stays where it moved to after the last price increase.

<AaveLoopingTrailingSlChart></AaveLoopingTrailingSlChart>

A trailing stop rides upward trends without a ceiling that might otherwise leave money on the table. And since it only moves up, it protects your gains when the market reverses, and once you're far enough in the green, you'll always exit at a profit.

There's no stale exit target set days or weeks ago. Instead, the trailing stop is the profit-taking mechanic and your upside is undefined until the market defines it. 

An upward trend has to reverse against you to hit it. And when it does, your trailing stop sees it and exits with most of the move captured: everything above your trailing distance from the last peak. You won't hit the exact top since it's always trailing behind, but you exit with gains locked and avoid watching them disappear if the reversal continues.


Calling the direction is only half the trade. How market-aware exits help you capture upside on leveraged Aave positions....

Capturing Upside on Aave Loops.



If you want leverage on your crypto holdings without handing custody to an exchange, looping is the cleanest path.

You keep your spot holdings and use them as collateral on a lending protocol like [Aave](https://aave.com), recursively borrowing against them to multiply your exposure. No counterparty. No funding rates. Just you, your collateral, and transparent onchain rules.

Just one drawback. 

Getting into a looped position manually requires dozens of individual transactions. Maintaining that position as prices move requires constant attention and quick action. Getting out requires even more work than getting in. Most people don't have the patience, the gas budget, or the operational discipline to execute this well over time.

Looping is powerful, but only if you can maintain it consistently.

## The Mechanic

Looping is recursive borrowing.

<AaveLoopingSpiral></AaveLoopingSpiral>

## Health Factor is the Only Number That Matters

When you're running a looped position, there are a lot of numbers you may pay attention to. The current price of <Token>ETH</Token>. Your total collateral value. How much you've borrowed. Your theoretical leverage multiplier. The APY you're earning on deposits. The interest rate you're paying on borrows.

You can forget all of them for a moment. The only number that determines whether your position survives another block is your account health factor.

Health factor is a ratio that Aave calculates continuously based on your current collateral value and your outstanding debt: 

$$\text{Health Factor} = \frac{\text{Collateral Value} \times \text{Liquidation Threshold}}{\text{Total Debt}}$$

This singel number tells you how close you are to liquidation, the point at which Aave will automatically sell your collateral to repay your debt.

**Collateral Value** is how much your deposited assets are currently worth in dollar terms. If you've deposited <Token>ETH</Token> and the price of <Token>ETH</Token> changes, your collateral value changes with it.

**Liquidation Threshold** is a percentage set by Aave for each asset type, representing how much of your collateral's value the protocol considers "usable" for backing your loans. Think of it as Aave saying "we'll count 83 cents of every dollar of <Token>ETH</Token> you've deposited when calculating whether you're safe."

**Total Debt** is the dollar value of everything you've borrowed. If you borrowed <Token>USDC</Token> (a stablecoin), this number stays relatively constant regardless of <Token>ETH</Token>'s price movements.

When your health factor equals 1, you're right at the liquidation threshold. Any lower and Aave's liquidators can step in and start selling your assets. You'll lose a chunk of your position to liquidation penalties, and you have no control over the timing or the execution price.

This is what we're trying to avoid at all costs.

Thankfully, this system works in the opposite direction too. The higher your health factor, the safer your position. A health factor of 2 means you have twice as much effective collateral as required to back your debt. A health factor of 1.5 gives you a 50% buffer. A health factor of 1.2 gives you a 20% buffer above the liquidation line.

<AaveLoopingHealthFactorLiquidiation></AaveLoopingHealthFactorLiquidiation>

Of course, the higher your health factor, the less leverage you have.

Conservative operators often maintain a health factor of 1.5 or higher, accepting lower leverage in exchange for a larger safety buffer. Using 1.5 as your basis, one can weather bigger price swings without needing to take action. More aggressive traders might run at 1.1 or even 1.05, maximizing their leverage while accepting that a relatively small adverse price movement could trigger liquidation.

There's no universally "right" answer. It depends on your risk tolerance, your conviction in the trade, how actively you can monitor and manage the position, and how much volatility you expect in the underlying asset.

## How Much Leverage Can I Get?

The next obvious question when understanding Aave looping is figuring out how much leverage you can really get exposure to. On Aaave, maximum leverage is a function of two variables: 

- the liquidation threshold of your collateral asset (set by Aave) and 
- the target health factor you want to maintain (your choice based on risk tolerance):

<AaveLoopingLeverageCalculator></AaveLoopingLeverageCalculator>

Lower health factors give you more leverage, but shrink your margin for error. At a health factor of 1.05, a price drop of less than 5% pushes you directly into liquidation territory. At 1.5, you can weather a 33% drop before liquidation becomes a concern.

If <Token>ETH</Token> goes up 10%, your leveraged position gains 10% times your leverage multiplier. If <Token>ETH</Token> goes down 10%, you lose 10% times your leverage multiplier. 

A 10% price drop at 3.5x leverage costs you 35% of your equity.

## How Many Loops Does It Take?

With our understanding of looping established the questions now becomes how much work we have to do to get our position set up at our target leverage. 

At this point, you'll find the the first major flaw with manual looping:

**You cannot reach your target leverage in a single transaction. Each loop only gets you partway there, with diminishing returns each time.**

When you deposit fresh collateral, your health factor improves because you have more assets backing your debt. When you borrow against that new collateral, your health factor drops because you've taken on more debt. Each cycle moves you closer to your target, but the amount you can safely borrow shrinks with each iteration. You're working with progressively smaller margins:

<AaveLoopingLoopsVisualization></AaveLoopingLoopsVisualization>

Amongst the team of Plug, we like to think of it as filling a container with a series of increasingly smaller cups. The first pour adds a lot. The second adds less. By the tenth or twelfth pour, you're adding tiny amounts to reach your goal.

To reach a target health factor of 1.2 starting from a fresh <Token>ETH</Token> deposit in an <Token>ETH</Token>/<Token>USDC</Token> long on Aave V3, you're looking at approximately:

- 13 separate deposit transactions
- 12 separate borrow transactions
- 12 separate swap transactions

Each transaction requires you to calculate exactly how much to borrow or deposit to move toward your target without overshooting. And each transaction is an opportunity to make a mistake: enter the wrong amount, approve the wrong token, set insufficient gas and have the transaction fail, or simply fat-finger a number and damage your position.

## How Do I Get Out?

Getting out of a looped position is just as tedious as getting in. Sometimes more so, because you might be exiting under pressure when prices are moving against you.

You can't simply withdraw all your collateral and walk away. Your debt is substantial, and attempting to withdraw too much collateral at once would push your health factor below 1, triggering liquidation. Aave enforces a maximum loan-to-value (LTV) ratio that limits how much collateral you can remove while maintaining a safe position.

For <Token>ETH</Token> on Aave V3, there are two key thresholds to understand:

- **Max LTV (~80%)** is the maximum percentage of your collateral value you can borrow against when opening or increasing a position. This is your ceiling for taking on new debt.

- **Liquidation LTV (~83%)** is the threshold at which your health factor hits 1 and liquidation begins. Go below this and you start losing collateral to liquidators.

The gap between these two percentages, roughly 3 percentage points, is your operating room for unwinding.

To exit a looped position, you need to work in reverse, step by step:

1. Withdraw as much collateral as you safely can without triggering liquidation (staying above the liquidation LTV)
2. Swap that withdrawn collateral for your debt token (<Token>ETH</Token> → <Token>USDC</Token> in our example)
3. Use those stablecoins to repay part of your debt
4. With less debt, you can now safely withdraw more collateral
5. Repeat until your debt is fully repaid

Only after your debt is completely cleared can you withdraw your remaining collateral along with any gains you've accumulated.

<AaveLoopingExitSteps></AaveLoopingExitSteps>

If it took you 40 transactions to enter the position at your target leverage, expect a similar number to exit cleanly. And if you're exiting because prices moved against you, you're doing this under time pressure while your health factor continues to deteriorate.

## Flashloans and Atomic Execution

Most people execute each step manually, one transaction at a time. Deposit. Wait for confirmation. Borrow. Wait. Swap. Wait. Deposit again. Flashloans collapse the entire looping process into a single atomic transaction.

Instead of manually walking up the leverage ladder one rung at a time, a flashloan lets you temporarily borrow exactly the amount of capital you need to move your position from where it is now to where it should be. No collateral required, no intermediate exposure, no partial states.

The key property that makes this safe is atomicity. All of the following happens in one transaction:

1. Borrow a large amount of capital via a flashloan
2. Use it to adjust your Aave position (depositing collateral, repaying debt, or both)
3. Borrow against the updated position
4. Repay the flashloan in full

If any step fails due to insufficient liquidity, price movement, invalid health factor, or unexpected constraint, the entire transaction reverts. The blockchain rolls back to the exact state it was in before the transaction started. You're never left half-levered or mid-exit.

<AaveLoopingOutcomes></AaveLoopingOutcomes>

When operating with manual steps, you have to think in terms of sequences of actions: deposit this much, borrow that much, swap this amount, and repeat. Each step depends on the successful completion of the previous one, and any miscalculation can throw off the entire process. Because of this, looping manually is error-prone and operationally complex.

With flashloans, we think in terms of states. Given your current position and the market conditions, what is the desired end state? How much collateral and debt do you want after this operation? The flashloan provides the exact capital needed to transition directly from your current state to your target state in one atomic step.

## Monitoring Never Stops

Flashloans reduce forty transactions to one. Markets don't wait for you. <Token>ETH</Token> moves while you sleep, while you're in meetings, while you're on a flight with no wifi. Your health factor drifts with every price tick, sometimes toward safety, sometimes toward liquidation. Maintaining a target health factor is a continuous process that runs as long as your position exists.

Say you're disciplined. You check your position every six hours: 6am, 12pm, 6pm, 12am. That's four check-ins per day, every day, for as long as your position exists. Each check-in isn't just glancing at a number. You're loading the Aave dashboard, reading your current health factor, checking the current price, mentally calculating whether you need to act, and if you do, executing a multi-step rebalance.

<AaveLoopingCheckFrequency></AaveLoopingCheckFrequency>

That's 28 check-ins per week. 120 per month. 1,460 per year. And that's assuming you never sleep past 6am, never get stuck in a meeting, never take a vacation where you're not thinking about your leveraged <Token>ETH</Token> position.

Even at four check-ins per day, you're still exposed for six hours at a time. <Token>ETH</Token> can move 10% in six hours. It's done it before. It'll do it again. At 3.5x leverage, that's a 35% hit to your equity. Enough to push you from comfortable to liquidated while you were in a movie theater with your phone on silent.

So maybe you check more often. Every two hours. Every hour. Now you're at 16 check-ins per day. 112 per week. You've turned position management into a part-time job. Your phone buzzes with price alerts. You wake up at night to check charts. Your partner asks why you're staring at your phone during dinner. The position that was supposed to make you money is now consuming your attention as a cost of keeping it alive.

And you're still not safe. Because even hourly check-ins leave gaps. Because you can't check while you're driving. Because you can't check during your kid's recital. Because you're a human being with a human life, and the market doesn't care about any of that.

Every rebalance you execute manually costs gas. At 3.5x leverage, you might need to rebalance dozens of times per month during volatile periods. Each one a multi-transaction affair if you're not using flashloans. Each one a potential mistake if you're tired or rushed or distracted.

## Automated Maintenance

The problem with manual maintenance isn't that it's hard. It's that it never ends. Every hour of every day, for as long as your position exists, you're either checking it or worrying about whether you should be checking it. The position owns a piece of your attention permanently.

Automation dissolves this entirely.

You wake up, and your position is exactly where you want it. You go to work, and your position is exactly where you want it. You have dinner with your family, and your position is exactly where you want it. The market crashes at 3am while you're asleep, and by the time you wake up, your position has already rebalanced itself back to target. You never had to do anything. You never had to know.

<AaveLoopingMaintenance></AaveLoopingMaintenance>

The math that used to require your active attention now runs continuously in the background. Every block, the system reads your position state. Every block, it compares where you are to where you want to be. When there's a gap, it calculates the exact adjustment and executes atomically. One flashloan-powered transaction. No multi-step sequences. No racing against price movements. No fumbling with interfaces while your health factor deteriorates.

This is what makes looping viable as a long-term strategy. The mechanics we covered earlier, the flashloans that collapse forty transactions into one, the health factor math that determines your leverage, none of it matters if you can't maintain the position consistently over time. Manual maintenance fails eventually. Not because you're not smart enough or disciplined enough, but because you're human. You sleep. You get distracted. You take vacations. You have a life outside of staring at charts.

Automation removes you from the critical path. The position doesn't need you to be available. It doesn't need you to be paying attention. It just stays where you want it, continuously, whether you're watching or not.

## State-Based Execution

Manual looping forces you to think in sequences. Deposit this much. Borrow that much. Swap here. Deposit again. Each step depends on the previous one. You're managing a chain of operations, and if any link breaks, you're left in an intermediate state trying to figure out what went wrong.

Automation inverts this entirely. Instead of specifying a sequence of actions, you specify a destination. Where do you want your position to be? What health factor represents the right balance between leverage and safety for you?

The system reads your current state: collateral, debt, prices. It computes where you are. It computes where you want to be. When the gap exceeds a threshold, it closes it. When it doesn't, it waits.

<AaveLoopingState></AaveLoopingState>

The entire decision reduces to one comparison. *Current debt versus target debt.*

- If you're carrying more debt than your target implies, you're overleveraged. Prices moved against you, or your health factor drifted below where you want it. The system repays the excess.

- If you're carrying less debt than your target allows, you have room to add leverage. Prices moved in your favor, or you deposited fresh collateral. The system borrows the difference.

- If they're close enough, you're already where you want to be. Nothing happens.

You're not telling a system how to manage your position step by step. You're declaring where your position should be, and letting the system figure out what that requires at any given moment. The target health factor is the only input. Everything else follows from that single number.

## Looping is Simple

The recursive borrowing. The health factor math. The dozens of transactions to enter. The dozens more to exit. The constant monitoring. The rebalancing. One sentence.

<AaveLoopingIntent></AaveLoopingIntent>

The collateral you're depositing. The asset you're borrowing. The safety buffer you're maintaining. Everything else — how many loops, when to rebalance, how much to borrow or repay — follows from those inputs.

You're declaring an outcome. The system reads your current state, computes your target state, and closes the gap. Entry, exit, and maintenance are all the same operation: state in, state out.

## This is What We Built

Everything in this post describes how [Plug](https://plug.to/intent/looping) approaches automated looping. The state-based execution model. The flashloan-powered atomic rebalancing. The continuous maintenance that runs whether you're paying attention or not.

We built Plug to make looping viable for people who don't want to make position management their full-time job. Set your target health factor, allocate your collateral, and the system handles everything else. Entry. Exit. Rebalancing. All of it.

If you've read this far, you understand the mechanics. Try it yourself.


Leverage without the casino. How looping on Aave lets you multiply exposure to spot holdings while staying in control of your collateral....

Looping on Aave.



TLDR: Crypto as an industry holds tremendous potential to redefine how money is used globally, but the requirement of manual transactions in a fragmented ecosystem has resulted in growing inefficiencies with no effective solution today. The introduction of automated strategies accessible in a single click enables users to realize many of the initial dreams of crypto that countless were sold on.

Crypto has the potential to change the way people use money forever.

The ideal world of crypto still feels like a dream. A world where you have real ownership of your money. Where you aren’t resorting to a bank with a 2/3 multi-sig between you, the bank, and government. Where you can spend your money how you please without concern of geographical restrictions or rules. Where you can escape local inflation and find safety in an asset that has more sound fiscal policy without a money printer that constantly dilutes your buying power.

You can boil everything down to: crypto is programmable money that lets people fully utilize their money however they prefer. It's control, freedom, transparency and verifiability all combined into a single financial offering. 

In 2021 a shift began, though. 

Transaction costs of Ethereum mainnet transactions had become prohibitive. It was very expensive to do even the most basic transactions. Optimizing gas consumption for smart contracts was critical. Without efficient models in place, protocols became effectively unusable.

As Layer 2s (L2s), transactions that post transaction records back to Ethereum, began spinning up the existing users and ecosystem found itself in a place where monetary and operational security was abstracted into smaller selective pieces. But, users could finally transact for fractions of a cent without making compromises on the benefits they gained. 

With the continued focus on driving user-facing costs lower the market eventually reached a point of hyper specialization where general L2s became app chains that aim to do one thing very well. Avoiding the value of network effects, protocols began optimizing for the lowest possible costs while introducing new central authority risks, walled gardens, and liquidity fragmentation that negatively impacted everyone and every protocol, including the app chain itself.

At the same time in another piece of the industry, we saw account abstraction take hold. Account abstraction in the form of EIP-4337 had two major goals:

- Enable new signature schemes that weren't reliant on existing private key mechanisms.
- Solve the cold-start problem that forced users to have money to pay for gas before running their first transaction.

Many developers and VC firms believed that the biggest user hurdle was how messages are signed and that the need for gas was a significant limiter of adoption. At the same time, we saw millions of dollars pour into passkey solutions that do simplify the user experience by introducing authentication methods native to the device the user is on like FaceId.

Yet, even with the continued growth and adoption of account abstraction, the core user experience did not and will not nominally change outside of being able to log in with your Google account or Device Passkey.

## Money as Cash

Still, with all the effort, the user experience largely remained the same and even degraded in several places. You are still required to do everything manually. You still have to choose favorite protocols. You still can't achieve the basic practices of money management like a savings account that generates consistent yield without risk.

In all regards, every single user of crypto has been left to use their magic internet money like it is cash:

- You must transact in person by clicking buttons one by one.
- You must pay current market rates instead of being able to unlock the capital efficiency of futures.
- You must constantly be aware and knowledgeable enough to manage your own finances because financial advisors don’t really exist for this sector.

The most simple things that we have become used to like rent auto pay, automatic credit card payments to cover debts, mortgages that draw from our savings fund on a set basis are not options today. Nothing of this sort exists for crypto at scale and it can’t in the current model due the explicit need for transactions that are signed by private keys or the use of protocols designed for explicit legacy transactions.

Even more drastically, you do not even have the capacity to operate in a market that never closes. Even if you work in crypto there is a zero percent chance that you spend multiple hours a day onchain or even inside the applications of crypto protocols.

![You are offline a majority of the day](https://cdn.plug.to/posts/why-we-built-plug/never-online.png)

You are at an inherent disadvantage. Everyone is. The broader ecosystem is being held back at the most fundamental layer by being forced to operate as if our crypto is cash rather than magic internet money as we know it to be.

In the end, so many non-crypto individuals liken the market to a degenerate equities market because in practice, it really is little more than that for most. The foundation for normal users to utilize their internet money like it’s actually digital doesn’t really exist.

## The “There’s Nothing to Do” Paradox

This issue is rooted deeper than priorities or user interest though. It’s not uncommon to hear participants of the current market remark that people do not care about decentralization; that all people want to do is gamble. For some, they aren’t far from the truth.

In reality, gambling is the product for *many*. But, what many often fail to realize is that carrying that belief is a statement of defeat. A perspective only formed through disgust and biased perspective without consideration of what the alternative truly looks like.

Those holding this perspective aren’t wrong, because well, there’s not much a normal user can do to get exposure to the benefits of crypto today. Unless you’re willing to become a psuedo-economist, the learning curve of how to use your money is much steeper than the difficulty ramp of buying crypto and holding it in spot. This is why only 1% of all crypto users use any semblance of DeFi. It’s unapproachable, confusing, and in general much riskier than other alternatives. Especially to people who are not willing to live and breathe the contents of the industry.

You have people trying, the basis is improving, but the experience pattern is still exceptionally subpar. So, the general user strapped with typical equity-market knowledge buys a few tokens, a few memecoins and forgets about it as they sit on their spot position while being completely blind to the real value the industry has to offer them; not really to their own fault.

Even for those that do know, the case is still much the same. When you summarize the general DeFi ecosystem you quickly realize that the majority of primitives today are focused on two things:

1. Asset acquisition.
2. Asset utilization.

With so little diversification your options for capital management are extremely limited. 

In most situations, users are really just choosing between a brand and the attached incentives that exist outside the base protocol. If the limitation stopped there it could be easily addressed, though. 

The deeper reality is that there simply isn’t much to do when everything requires you perform every action manually. Users can't really be glued to their devices at all time. Even if they choose to be, there isn't enough in crypto that provides entertainment to be online 24/7.

For many, there exists no interest in doing research about all the options before deciding where they should use their capital. Even when users finally understand a protocol they have no way of comparing it to the best rates or determine what gives them the best outcomes without having vetted every option available.

As a new market entrant your pool of options is small. Knowledge isn’t implicit, but ignorance is. It takes years to understand the new models in place. Without a close network of people that are deeply integrated it can be weeks until you even discover a protocol that gives you the functionality you are looking for.

Some chalk this up to discovery quality being poor, but really it’s that delivery is poor. Even with a vastly improved discovery process users will not have a vastly improved experience. 

A user should not need to know these things or do this work to get the benefit of crypto. Until they can get the benefits without such an extreme level of required knowledge, the market will feel empty and the general consumer of the world will stay far away. Until it as simple as depositing into a bank account and immediately earning yield, there is no hope for real mass adoption.

## Billions in Inefficiencies 

Without people transacting though, there is a constant lack of liquidity. Coordination of people is difficult. Coordination of liquidity is abysmal. There’s forever several yield protocols offering exceptionally high yield rates as they vie to become a king of the market. Forced to overpay, incentives flow in a way that results in limited growth and parasitic tendencies simply because a certain mechanism has not been capable of securing enough liquidity to function.

Perpetually compared to traditional rates of a bank account, users must make the constant decision if the newly introduced risk by crypto is worth the additional yield.

Today, fragmentation of chains has exacerbated this risk and knowlege issue. Users have more money onchain but that money is less concentrated than ever before. It’s distracted in all the worst ways:

- It’s spread across several different chains, many of them being fundamentally incompatible with one another.
- It’s siloed into countless wallets and continues to grow in disparity as embedded wallets continue to be pitched as a major value prop. because now users can sign up with their email.
- It’s delivered through wallet apps that show a single token across different chains as unique assets because the team can’t figure out how to unify the canonical reference with the social ones.

In every way, using your money onchain today is significantly worse than it was years ago. As an industry a lot of money and labor has been spent, but what benefit did it actually give users that are here today? Effectively nothing.

Because of this, protocols for the most part, operate in a worse ecosystem than ever before. The patterns needed to enable effective operation have disappeared. It is not that the market became competitive. It is not that the protocol isn’t appealing. The fundamental thesis and promise of blockchains and the value of network effects, simply put, was broken. Users aren’t the only ones that suffer, protocols feels that effect even more and this flywheel is accelerated by every investment into a hot new L2 that’s chasing the opportunity to allocate 40% of its token to investors.

It is the money ouroboros of the industry. So, while it feels bad today, it is only going to get much worse if a solution does not become available very soon.

## Chain Abstraction

Finally though, there’s at least real conversation about this problem. Primarily in the form of *chain abstraction* which is a commonly held belief that the path to correction here is one led by the idea that balances across all chains should be utilized as one. For a simple example here:

![Chain abstraction money flow](https://cdn.plug.to/posts/why-we-built-plug/chain-abstractions.png)

- If you have USDC on Base, but want it on Arbitrum, you should be able to use that money with ease.

Unfortunately though, this belief is good in nature but exceptionally weak in reasoning tolerance while being exceptionally idealistic. Rather than fixing the fundamental problem, chain abstractions is permission granting to exacerbate the problem and leans into the hideous nature of a system where fragmentation is a systemic issue that’s never properly addressed.

While it seems to track logically, the idea quickly falls apart as you begin to dig into what this direction really means and what it enables. We’ve covered a basic example of the hopeful outputs, but we must consider what benefit, we, the users of the industry, get out of it. In the simplest answer, you get little tangible benefit:

- Your experience is still worse than it was years ago.
- Your settlement and transaction times are longer and more error-prone.
- Your cost of interactions grows significantly now that complexity of even the most simple transactions has been multiplied by many factors.
- The risk profile grows substantially as you introduce more middle men and non-atomic settlement into the standard execution path.
- Your ability to utilize the efforts of the last years effectively vanishes as things are siloed into their own ecosystem.

In nearly every single situation, a philosophy of *one balance* is delivering users a trash experience that has been disguised as a cherry pie with a dollop of whipped cream on top. It is a step backwards covered in a mirage of technical jargon and improvement. It's an idea simple to sell to the non-technical. But, it is exceptionally hard to build around, insanely detached from real-world benefit, and is stuck at square one where you can count those making real progress and improvements on one hand.

The idea that chain abstraction is a solution is especially confusing when acknowledging that leading wallet applications have been stagnant for years after having done little more than copy-pasting the designs of one another with little change or evolution... And users don't easily change the wallet they daily-drive.

Yet, it is a righteous desire. I don't discount them or blame them for trying. There's a group of people working to improve the space with a temporary solution while the long-term one is established. Chain abstraction simply isn't the most direct or realistic path to an improved ecosystem or user experience.

## Directionally Correct

So, if we understand the problem to result in a bad user experience and ineffective liquidity management what can we do to improve that? Really, it's simple. It's just highly under-funded and under-developed.

The obvious answer here is enable *atomic transaction automation*.

In the last few years there have been several attempts to do this. You do have platforms like [Gelato](https://www.gelato.network/), but it was made for the highly technical and failed to enable the general end-user. You still have to write code to get any level of functionality while dealing with a much worse user experience. Even more recently they have pivoted and directed their focus away from improving this product. Antithetically too, you are trusting Gelato with the outputs of automation and thus inputs of transactions. 

So, not only have users not been empowered with the functionality that brings real improvement to the industry, the only real option also comes with a big set of drawbacks that have made the rate of adoption extremely low. More importantly, the general consumer and blockchain user still effectively has no option to choose from.

## Automation Is Not Solved

In the meantime though, a few protocols have risen that claim to empower users with the capabilities of automation. Generally, they are using the word incorrectly and are making a claim that is fundamentally false. Instead, these protocols are really offering increased yield through managed vaults that have a single vault like:

1. Users deposit into a vault.
2. The operator of the vault rebalances the position.
3. Yield is increased due to centralized management.

The user has not been empowered to automate anything. The user deposits into a vault that they have no real control or influence over. Users of yielding-vaults have been empowered with an increase in yield, not automation.

Still today users are left without any real option to create strategies or even to adopt strategies that already exist. Even the most technical developers such as Foundry framework developers struggle to provide this functionality to themselves after having invested hundreds of hours into building a system of their own. Of course, there are MEV bot frameworks that you can adopt, but you are left to do everything yourself. 

There is not a single market-accessible automation solution that supports general execution and highly customized strategies without requiring the user to be exceptionally sophisticated.

## Our Future

We are here to solve this with Plug. 

Plug is the single destination for all your crypto activities in one place. We're not just another wallet or interface - we're building a comprehensive platform that fundamentally changes how you interact with blockchain:

- **Multi-account portfolio management**: Unified view and control of all your assets across different wallets and chains.

- **Complete ecosystem composability**: Interact with any protocol through a single, intuitive interface.

- **Automated strategies with granular control**: Create, customize, and deploy sophisticated transaction strategies without writing code.

- **Reactive runtime transactions with coils**: Dynamic data-driven transactions that adapt to market conditions in real-time.

- **Set-and-forget automation**: Systems that optimize your positions 24/7 without requiring constant monitoring.

What all of this enables is a set of experiences and features that cannot be found anywhere else in the crypto ecosystem. As we get closer to our public launch, we'll share more details on each of these capabilities and how they work together to create a seamless experience.

It should be clear that we are here to redefine what the typical user experience looks like and deliver automated-enabled features that help you outperform. It's not another piece of infrastructure designed to only be used by 20 companies. 

Plug has been a venture of passion built by rethinking every small detail of how you interact with blockchains today. It's been crafted with the hindsight of past mistakes and the foresight of a clear future where humans no longer need to manually execute every blockchain transaction. We've prioritized a user-first mindset rather than a tech-first approach, always keeping your needs and experience at the center of our design philosophy.

The journey to redefining crypto interactions starts here. Make sure to [follow along on Twitter](https://twitter.com/try_plug) so that you are the first to know as we reach the next steps.


Crypto has the potential to change the way people use money for decades to come. It feels like a dream where you have real ownership of your money. Where you arent resorting to a...

Why We Built Plug.



Every morning, I wake up and start working with a symphony of AI assistants. Claude helps architect our systems, Cursor generates our code, ChatGPT brainstorms solutions, Perplexity researches edge cases, the list goes on. My reality is highly AI-augmented.

So when someone sends me yet another crypto agent chat interface, I get why they're excited. The promise is intoxicating...

"What if you could just tell an AI to make you money?"

Just tell an AI what you want, and it handles all the complexity of crypto for you. No more juggling DEX interfaces, tracking yield farms, or monitoring positions across chains. Just vibes and gains.

But I'm frustrated because no one has shown me an agent that can do something other than swap or bridge. No one has shown me a chat interface for transaction definition that actually works. Right now, we're swimming in demos and pitch decks while hard problems remain unsolved.

Although it's early, there's an exciting future for these proof of concept ideas. Many societal markers point towards a future with systems that transact on behalf of humans using crypto: users believe in this future, investors believe in this future enough to fund it, builders are attempting to create this future, etc.

Last week we budgeted a few hours to explore what a chat interface for Plug might look like. It is scrappy, but it's better than every single market-available "agent" that exists today.

Morgan can read your wallet contents, build and discover Plugs to use, suggest actions based on your goals, run and schedule your Plugs, re-organize the app with a live context-based layout, etc. It only took a ~300 lines of code to significantly improve upon the experience that is readily available today.

![An example of Plug's chat interface in action](https://cdn.plug.to/posts/chat-interfaces/1-morgan.png)

If you want to try Morgan out someday, sign up for the [Plug waitlist](https://plug.to).

After testing other crypto AI agents and exploring the chat interface in our product, I've come to a realization: we're asking the wrong questions about what AI should do in crypto.

## Current State of Crypto AI Agents

The gap between promise and reality becomes clear when we examine actual implementations. Let's look at some leading attempts at crypto AI agents to understand what their successes and limitations reveal about our current approach to AI in crypto.

### Nani.ooo

Nani was one of the first intent agents that I came across midway through 2024 and became the first “agent” project I tried out. When I first tried nani.ooo, it was a Windows Desktop-esque experience with different apps I could click into, one of which was the chat interface. After depositing ETH, I was able to use the chat interface to swap to NEETH (their own token).

When I try to use the interface today, the experience is more similar to ChatGPT and it does seem to try to write an intent and post it to the Nani Deployer contract.

![Nani.ooo interface writing an intent using an LLM chat interface](https://cdn.plug.to/posts/chat-interfaces/2-nani.png)

When I click EXECUTE ON SMART WALLET, I get error messages that don’t allow me to move forward. I see that there are some other commands written to the contract on Basescan.

![Basescan interface showing transactions to the Nani Deployer contract](https://cdn.plug.to/posts/chat-interfaces/3-basescan.png)

My experience ended here. My understanding is that in it's current state, Nani is more of a set of developer tools than a consumer product.

### Griffain

After trading the $GRIFFAIN AI memecoin, I finally was able to try out the platform. I had to spend 2 SOL to get access and then ended up in an interface with a bunch of different “agents” available to me.

![Griffain agent marketplace](https://cdn.plug.to/posts/chat-interfaces/4-griffain.png)

I chose to interact with the Sniper Bot and did not have the best experience. I was expecting to have a back and forth with the agent about what we’d be doing together but instead it felt like I kicked off an open script to buy memecoins based on parameters loosely defined in my sentence: Only snipe if the description mentions AI.

![Griffain sniper bot](https://cdn.plug.to/posts/chat-interfaces/5-griffain.png)

When we think about generalized intents, should the AI help you devise the intent or should the AI write the intent for you? At which point do you give over the wheel and say send it?

## The Chat Interface Oversimplification

Using a chat interface to write financial transaction instructions isn't just inefficient - it's technological regression. We've moved from command line interfaces to graphical UIs because they're more efficient, only to circle back to essentially typing commands in natural language? It's like replacing your banking app with a local bank branch.

The promise of AI isn't in making simple tasks more complicated - it's in making complex tasks more approachable. Yet current crypto chat interfaces often add unnecessary steps to straightforward operations while failing to meaningfully handle complex ones.

## The Intent Behind AI Agent Usage

My user experience with these products has led me to wonder what users truly want out of chat interfaces and AI agent interactions?
Using LLMs in our worfklows adds value because we can…

- Offload decision making and responsibility
- Abstract complexity
- Be met where we are informationally
- Interact with a personality that guides and entertains us
  Interacting with software through an anthropomorphized chat interface isn’t a wholly new concept but it’s one that has been highly re-popularized since the release of ChatGPT in late 2022.

  Early story based video games could be interacted with through a chat interface that allowed players to type commands to move through the story.

  While software products with buttons communicate where the boundaries are, chat interfaces allow you to think anything is possible… even if it isn’t. The blackbox aspects of LLM chatbots lead to a sense of wonder – one of the few pieces of consumer technology that still feels magical to us today.
  But as Chance mentions in [The Glass Box](https://chance.utc24.io/paper/glass-box/):

> _These models optimize for scale, minimizing the cognitive load on users. The complexity is hidden to provide an interface that "just works." But here lies the flaw: the more hidden the system, the more prone it becomes to misuse, misunderstanding, and distrust. It introduces fragility where transparency could build resilience._

By trading an aspect of our autonomy for convenience and wonder when offloading decision making to opaque LLMs, we introduce room for influence and error.

## Real Utility in AI Crypto Agents

In many cases, trading off nuance control to an LLM for speed in output is net positive. Earlier this month, [Andrej Karpathy](https://x.com/karpathy/status/1886192184808149383) beautifully articulated a feeling that a lot of people have been feeling recently – a type of working flow state wherein you code via prompts.
![Andrej Karpathy vibe coding tweet](https://cdn.plug.to/posts/chat-interfaces/8-vibecoding.png)

> _There's a new kind of coding I call "vibe coding", where you fully give in to the vibes, embrace exponentials, and forget that the code even exists. It's possible because the LLMs (e.g. Cursor Composer w Sonnet) are getting too good. Also I just talk to Composer with SuperWhisper so I barely even touch the keyboard. I ask for the dumbest things like "decrease the padding on the sidebar by half" because I'm too lazy to find it. I "Accept All" always, I don't read the diffs anymore. When I get error messages I just copy paste them in with no comment, usually that fixes it. The code grows beyond my usual comprehension, I'd have to really read through it for a while. Sometimes the LLMs can't fix a bug so I just work around it or ask for random changes until it goes away. It's not too bad for throwaway weekend projects, but still quite amusing. I'm building a project or webapp, but it's not really coding \- I just see stuff, say stuff, run stuff, and copy paste stuff, and it mostly works._

When I use [Cursor](https://www.cursor.com/) and [Claude](https://claude.ai), I sometimes reach this flow state and push features faster than expected. At other times, I find myself in a deadend and have to dump active changes and restart at the most recent working commit.

Vibe coding works in software developments thanks to the ability to revert changes. It's a different story for onchain transactions.

Do you really want to vibe code your financial activities?

You could get away with vibe coding a single trading wallet – this is essentially what I did with Griffain. I said, “Hey I’m feeling frisky today let’s buy some memecoins that fit my parameters” and lil buddy gave me exactly what I wanted.

![Griffain Sniper Bot](https://cdn.plug.to/posts/chat-interfaces/9-griffain.png)

The Griffain Sniper Bot I used started buying things quickly and I didn’t have time to respond before it chewed through my deposits; a risk of automation (especially in the context of pseudo-gambling memecoins).

My experience using AI in development shows how AI can be a powerful thought partner when building complex systems. What if we applied this same collaborative framework to crypto? Instead of asking AI to autonomously manage our assets, what if we used it to help us make better decisions about them?

A different model emerges - one of purposeful collaboration rather than autonomous execution. This suggests a more nuanced approach to AI agents in crypto.

## Building Infrastructure for Agents

Right now, most crypto AI interfaces can swap and bridge because that's all their underlying infrastructure allows. The multi-function agentic future we envision requires more work to achieve.

This is precisely why we're building Plug the way we are. We're not starting with a chat interface or a single omniscient agent – we're building the foundational infrastructure that enables meaningful agent collaboration. A robust solver that can compose complex transactions across protocols. A growing library of protocol integrations. A framework for writing and executing generalized intents.

When we integrate a protocol into Plug, we're expanding the universe of what's possible for every agent in the ecosystem. Each integration creates new possibilities for composition and automation. We're starting from first principles, focusing on the fundamentals that will empower both humans and agents to do more with crypto.


Every morning, I wake up and start working with a symphony of AI assistants. Claude helps architect our systems, Cursor generates our code, ChatGPT brainstorms solutions, Perplexit...

Chat Interfaces and Crypto Agents.



We are Terminally Online Inc. and you may know us individually as [danner](https://twitter.com/drakedanner) or [chance](https://twitter.com/nftchance). We've spent the past 5 years plugged into the EVM landscape and we're here to plug you in too.

## The Reality Check

If you're reading this, you probably have a setup that looks familiar: Multiple monitors, endless Discord and Telegram notifications, and more browser windows than your RAM signed up for. The state of DeFi feels like trying to play 4D chess while juggling. You've got yield farms here, LP positions there, and god forbid you try to time a transaction across multiple protocols without missing the perfect entry.

We've been there. We are there. And we're building the solution we've always wanted. Initially, when we set out to build Plug, we considered building a product that allowed users to log off and spend more time touching grass. As we continued to build, we realized - that's not who we are; that's not who you are.

Let's be real - I've got 47 browser tabs open right now. This isn't just a problem to solve - it's who we are. The question isn't how to log off, it's how to become even more online. We live in the ether, we spend our days streaming our homes to those we build with. We named our company Terminally Online for a reason. We don't log off and we are here to build for others like us.

## Our Journey Here

I've spent my entire life seeking the cutting edge of functional technology and my entire career in early stage fintech and crypto startups. I've had the opportunity to build teams and hire across every department imaginable. I've gotten to perform a laundry list of operational and technical roles and the teams I've worked with have built systems that have processed $5b+ across compliant Web2 and Web3 rails. I've gotten to work with Chance over the years as he's enabled nearly a million gas optimized transactions and developed delightful software experiences.
We're excited to begin releasing product that we fully own and direct.

## Meet Plug

We're not here to tell you to touch grass. We're here to build the command center for the terminally online. Your protocols, your strategies, your automations - all running exactly how you want them, when you want them. No more tab juggling required.
For the first time ever, you can:

- Schedule constraints-driven transactions (because sometimes you need to sleep)
- Access all major protocol functionality without bouncing between apps
- Create and share strategies that actually make you money
- Set up "if this, then that" executions that squeeze maximum value from every move
  One interface to access Ethereum, one interface to combine protocols, one interface to schedule transactions, and one interface to manage your onchain experience.

## What's Coming

We're starting with Season 0 - our founding users phase. This initial release will be referral-gated, with priority access for everyone on the Plug waitlist. Being a founding user means more than just early access; it comes with built-in advantages that persist:

Your transactions will be evaluated more frequently, leading to better execution. We'll subsidize your gas costs on L2s, and you'll get early access to new features as we roll them out.

We're taking a seasonal approach to give us flexibility - each season lasting between one to several months. This structure lets us integrate new protocols, test incentive alignment mechanisms, and evolve the product ecosystem based on what we learn together.

When we transition to Season 1, our founding users keep their enhanced capabilities. We're building Plug for the long term, and we want our earliest users to remain at the forefront of its evolution.

## The Future

This isn't just another DeFi tool. We're building the infrastructure for the next generation of onchain activity. A platform where users can compose, automate, and execute complex strategies without compromising on control or capability. This is about unlocking the true potential of being terminally online.

Ready to plug in? Join the waitlist at [plug.to](https://www.plug.to).


We are Terminally Online Inc. and you may know us individually as danner or chance. Weve spent the past 5 years plugged into the EVM landscape and were here to plug you in too....

Collapse 50 onchain transactions into 1 Plug.

A backend to plug-and-play

An app to build and run complex transactions