

We had <Token>ETH</Token>, needed liquidity, but didn't want to sell and eat the tax bill or miss out on the upside we were waiting for. So we took a loan against our <Token>ETH</Token> on [Aave](https://aave.com). No credit check, no application, no waiting for approval. The rate is often lower than what a personal loan or credit card would cost, and we keep our <Token>ETH</Token>. That last part was the whole point.

We deposited 3 <Token>ETH</Token> to borrow 4,500 <Token>USDC</Token>. For about a week it felt like every other loan we've taken. But this one had no payment schedule or path to zero built in. No structure on day one like traditional loans. We had to figure out what to pay each cycle and manually make the payments ourselves. No clean math, no reminders, no auto-pay.

So we built the structure ourselves. And once we did, we never had to think about it again.

## DeFi Loans Are Open Ended

Every traditional loan we've dealt with has the same basic shape: a schedule, a payment amount, a maturity date, and a defined path from "I owe this" to "I'm done." With mortgages, car loans, student loans, and even variable-rate products, we know what we owe and when we'll be finished owing it. That clarity is built in on day one.

In DeFi, there's no payment schedule nudging us to close it out, no monthly bill chipping away at principal, no maturity date to work towards. Without that structure, many people don't sustain the position for very long: 48% of Aave borrowers who fully close their loan do so within the first month. And of those who stay past thirty days without making a single repayment, one in three gets liquidated within 100 days as prices move against them.

Every payment on a traditional loan reduces what we owe, moves us further from default, and stops interest from compounding against us. The same mechanic exists in DeFi: each repayment shrinks our debt and improves our loan health. The protocol just never tells us to make one. There's no bill arriving, no late fee, no system holding us to anything. Just us and a position that keeps drifting.

When we opened our loan, we realized we had to figure out how to pay it off in 12 months by ourselves, then show up week after week to ensure we stayed on track. Not making payments wasn't an option. We knew we had to make regular payments to keep our balance moving toward zero and our position safe.

## Making Fixed Payments

We took the loan at a 50% LTV, borrowing 4,500 <Token>USDC</Token> against $9,000 of <Token>ETH</Token> collateral. <Token>ETH</Token> would need to fall roughly 40% before we approached liquidation territory. We had room, and we had a plan.

We did the math: $4,500 divided by 52 weeks was $87 a week. We set a calendar reminder to repay this amount every week for the next year to chip away at our principal and stay on track. We knew this was a big commitment, but we didn’t have any other choice.

After a few tedious weeks of opening the Aave web app every Monday, clicking repay, entering our amount, and signing the transaction, we got tired of being on call to show up. So we built a plug that would show up for us instead. The idea behind [Plug](https://plug.to/app) is simple: define an intent once and let it execute on our behalf. 

<PlugEmbed id="3c3fb2cf-5f5a-43b9-8b97-19b0224ddb55"></PlugEmbed>

We set it up to run once a week for 52 weeks. The first time it ran, it checked if a position was already open. Since we had already deposited our <Token>ETH</Token> and borrowed <Token>USDC</Token>, it skipped straight to the repayment. Every week after that, it repaid a fixed $87 until the schedule was complete.

Setting and forgetting our payment schedule was the quick win we needed, so we stopped checking the position every week and carried on knowing the plug was handling everything for us. 

Then a few weeks later we checked our debt balance and it wasn't where we expected. We were already behind by $26 on week 6\. Payments were being made, but our math wasn't right. Our fixed payments weren't accounting for interest accruing on top of our debt. Our borrow rate moved up and down, spiked when everyone showed up to borrow <Token>USDC</Token> at the same time, and our debt moved with it.

The $87 we calculated on day one was based on what we borrowed, not what we really owed. What we owed kept growing: rates spiked, interest accrued faster than $87 could pay it down, and because the payment never changed, it never caught up. 

## Keeping Up With What We Owed

Since we weren't accounting for interest accruing on top of our debt, our payoff date was a moving target.

We needed to repay exactly what we owed each week to protect our 12 month timeline. So we immediately updated our plug to check our live debt balance instead of the static 4,500 <Token>USDC</Token> borrow amount.

<PlugEmbed id="5f96c4b3-1049-4418-a395-03a5dcac86c7"></PlugEmbed>

We updated it to read our live debt balance from Aave: the principal plus accrued interest. Then divided that result by 52 instead of repaying a fixed $87. Every payment was now based on what we actually owed that week, not what we borrowed on day one.

No more stale data. But once again, we realized our logic was still flawed. We were dividing the totalBaseDebt by 52 on each run. But 52 was the total number of weeks in our schedule, not the number of weeks we had left. By week 26 we would have 26 weeks to close the loan, not 52\. So dividing by 52 at that point would cause the plug to think we had twice as long as we actually did and would calculate payments that were too small to close on time.

So we made one more update to our plug: divide totalBaseDebt by however many weeks were left in our schedule. That way, as the schedule counted down, the denominator shrank and the payment adjusted accordingly.

<PlugEmbed id="cae6faf0-efee-4521-b531-818736448516"></PlugEmbed>

Now the formula knew exactly where we were every week. Live balance on top, weeks remaining on the bottom. Rates spiked, balance grew, payment adjusted up. Rates settled, payment came back down. As the weeks passed by, the payment cleared whatever remained.

That logic held all the way to the final week. On week 52, weeks remaining was 1, so the payment was simply totalDebtBase. Plugs are atomic, so every step, read, calculate, and repay executed inside a single transaction. No dust, no room for error. The loan closed to exactly zero.

We simulated this against a fixed schedule across 52 weeks with rates swinging between 2.83% and 7.59%. Fixed payments left $121.60 still owed at week 52\. Reactive payments left nothing.

## Repaying On Our Terms

This is the structure every traditional loan comes with. A payment schedule that always knows what we owe, adjusts when rates move, and gives us a clear path to zero. Now our DeFi loans have it too.

We had assumed taking a loan on Aave would force us to always be there. No structure built in meant we had to define and execute it ourselves. It took us a few times to get everything right, but we eventually got the formula and logic we needed. And once we did, our plug executed on our behalf for a year, managing payments more accurately and reliably than we ever could have manually. Our loan still required constant attention, but we didn't need to be the ones paying attention anymore.

We never had to think about it once the plug was running. The loan closed on week 52, we kept our <Token>ETH</Token>, and moved onto the next trade. Next time we won't figure out our payment plan as we go. We'll simply use the plug.


Paying off a DeFi loan sounds simple until you realize theres no payment schedule, no due date, and no system telling you what to do. Heres how we built one....

Repaying A Loan On Aave.



If you own crypto and need cash, you have a problem most people don't realize has been solved. The options aren't great: sell your <Token>ETH</Token> and eat the tax bill, or just don't access the money at all. Your crypto sits there appreciating (hopefully) while your bank account stays empty.

But there's a third option. You can borrow against your crypto, the same way someone borrows against their house or their stock portfolio. You deposit your <Token>ETH</Token> as collateral and borrow dollars against it. You keep the <Token>ETH</Token>. You get the cash. If <Token>ETH</Token> goes up, you still own the upside. You pay the loan back whenever you want.

This is what lending protocols like [Aave](https://aave.com) exist for. No credit check. No income verification. No bank deciding whether you deserve access to your own wealth. You connect a wallet, deposit collateral, and borrow. The whole thing takes minutes.

So that's what we're doing. We're depositing <Token>ETH</Token> on Aave, borrowing <Token>USDC</Token> (a stablecoin pegged to the dollar) against it, and sending the proceeds to [Coinbase](https://coinbase.com) to cash out. Money hits the bank account the next morning. We owe roughly 3% APR on what we borrowed. Cheaper than a credit card, cheaper than most personal loans, and we didn't have to ask anyone's permission.

For about a week it feels like every other loan we've taken out. Easy. Forgettable. Like it's just sitting there quietly costing us a few bucks a day.

Then we start paying attention to what it's costing us.

## The Rate Won't Sit Still

Every loan we've ever taken out had a number attached to it that didn't move. A mortgage at 6.75%. A car loan at 4.9%. Even a variable-rate credit card tells you the range and gives you notice before it adjusts. You sign, you know what you're paying, and that number stays put long enough to plan around.

Our Aave rate has moved three times this week. We got in at 3% APR. Monday it was 2.5%. Wednesday it hit 6%. This morning it's sitting at 4.1%. There's no notification when it changes. No letter in the mail, no email, no alert. The rate just moves because someone else borrowed more <Token>USDC</Token> from the same pool, or because a wave of repayments freed up supply and demand shifted. Our cost of borrowing is a live market variable that we have zero control over and no way to predict.

This is what it looks like in practice. A fixed rate holds a line. Our rate doesn't know what a line is.

<AaveBorrowingLoanComparison></AaveBorrowingLoanComparison>

A fixed-rate borrower can forget their loan exists for months and nothing changes. We can't forget ours for a day. Every hour the rate sits above what we planned for, the position costs more than we budgeted. Every spike we miss is money we didn't know we were spending.

And the rate is only half of it. Aave is also constantly watching the ratio between what our collateral is worth and what we owe. That ratio is called our health factor. If <Token>ETH</Token> drops enough, the protocol doesn't call us and ask for a payment. It starts selling our collateral to cover the debt. No warning, no grace period, no phone call from the bank. Over the past six months, one in seven wallets that deposited <Token>ETH</Token> and borrowed <Token>USDC</Token> against it, the most basic thing you can do on the protocol, lost collateral this way. People who did exactly what we just did and went about their lives.

So now we're tracking a rate that won't sit still and a position that can deteriorate while we sleep. What we have is a leveraged position. The interface called it borrowing. The mechanics are directional exposure to <Token>ETH</Token> with a liquidation threshold. The difference between those two mental models is where every cost we didn't plan for comes from.

## There's No Path to Repayment

Every loan most of us have dealt with has the same basic shape. You borrow a number. You make payments on a schedule. The balance goes down. Eventually it hits zero and you're done. Mortgages, car loans, student loans — even variable-rate products give you a monthly bill and a date when it ends. The structure itself does the work of pushing you toward zero whether you think about it or not.

Our Aave position doesn't push us anywhere. There's no schedule, no monthly bill, no maturity date, no finish line. Interest accrues every second at whatever the variable rate happens to be, and the balance drifts further from zero every day. Nothing nudges us to close it out. Nothing chips away at the principal. The protocol doesn't care if we repay in a week or never.

<AaveBorrowingDebtComparison></AaveBorrowingDebtComparison>

One line heads toward zero. The other one doesn't even know zero exists. That open-endedness sounds like freedom. It's a trap.

When there's no structure pushing you toward repayment, you have to build it yourself. Almost nobody does. 48% of Aave borrowers who fully close their position do so within the first month — not because they planned to, but because they couldn't sustain it. Roughly half of us bail before thirty days. Of those who stay without a defined exit, one in three gets liquidated within 100 days.

And the interest isn't even what kills them. We took on $4,500 at roughly 3% APR. That's about $135 a year. Cheap. But a 20% move in <Token>ETH</Token> swings the value of our position by $1,800. The interest is a rounding error next to the market risk we're carrying. A loan's worst case is that you overpay on interest. Our worst case is that we lose everything we put in.

If nothing in the system is pushing us toward repayment, we need to decide right now: when are we closing this? At what price? Under what conditions? The position won't answer those questions for us. Every day we defer the answer, the exposure compounds.

## No Grace Period, No Warning

We borrowed <Token>USDC</Token> at 3% because that's what the interface showed when we opened the position. But Aave supports multiple stablecoins, each with its own borrow rate. At the moment we borrowed, <Token>GHO</Token> was sitting at 1.5%. <Token>DAI</Token> was at 2.1%. We picked <Token>USDC</Token> because it's what we knew, and that familiarity is costing us roughly double what the cheapest option would have.

When you take out a mortgage, you shop rates from a few lenders, pick one, and lock it in. Done. You know what you'll pay for the next 30 years. When you finance a car, the paperwork tells you the total cost of interest over the life of the loan. These numbers don't change once you sign.

Our rate is a function of pool utilization, meaning how many other people are borrowing the same asset at the same time. When the market heats up and everyone borrows <Token>USDC</Token> at once, our 3% can become 8% overnight. When borrowers rush to repay and the pool empties out, it swings back just as fast. We have no control over this and no way to predict it. The rate is a live market variable, like the price of the collateral itself.

<AaveBorrowingRiskAbsorption></AaveBorrowingRiskAbsorption>

A week at 3% is cheap. A month where the rate spikes to 7% for ten days in the middle changes the math entirely. And unlike a variable-rate mortgage that adjusts once a year with advance notice, our rate adjusts continuously with no notice at all. We can't tell you what this position will cost next week, let alone next month.

At minimum, we should have compared rates across stablecoins before we borrowed. We didn't, and now we're paying double what the cheapest option would have cost.

## The Exit Is a Moving Target

You can prepay a car loan on any given Tuesday. Call the bank, get a payoff amount, wire the funds, done. That number is remaining principal plus accrued interest. It moves slowly and predictably.

Closing our Aave position is simple mechanically. Repay the <Token>USDC</Token>, withdraw the <Token>ETH</Token>. But how much that costs us, or makes us, depends entirely on what <Token>ETH</Token> is worth the moment we hit the button.

We deposited 3 <Token>ETH</Token> at $3,000 and borrowed $4,500 in <Token>USDC</Token>. That's 50% of our collateral's value, which Aave calls the loan-to-value ratio, or LTV. Close at $3,200 and we get back 3 <Token>ETH</Token> worth $9,600, minus the $4,500 debt. Up $600 on collateral appreciation. Close at $2,000 and the same 3 <Token>ETH</Token> is worth $6,000 minus that same $4,500. Down $3,000. Same position, same intent, completely different outcomes depending on when we close.

No loan works this way. The debt is fixed in dollar terms. The collateral isn't. That asymmetry is leverage, and it means the exit is never neutral. Every day we hold this position, we're making a directional bet on <Token>ETH</Token> whether we meant to or not.

<AaveBorrowingExitComparison></AaveBorrowingExitComparison>

Half of Aave borrowers cash out their borrowed stablecoins immediately. Borrow, send to an exchange, withdraw to their bank. The cash is in hand. The original goal is met. But the position they left behind still has a value that depends entirely on the market when they eventually close it. And when it comes time to exit, [the timing question gets even harder](https://plug.to/posts/capturing-upside-on-aave-loops).

We need exit conditions defined before we need them, not while we're staring at a chart at 2am trying to decide if <Token>ETH</Token> has bottomed.

## The Cost of Not Watching

A bank loan asks for one thing a month: a payment. Most people automate it. After origination the loan basically disappears from your life. You set up autopay and forget about it for five years.

Our Aave position stays with us. We're watching <Token>ETH</Token> to make sure our health factor holds, tracking the borrow rate to see what the position is costing us, and trying to figure out when to close.

<AaveBorrowingVolatileChart></AaveBorrowingVolatileChart>

Our life now: checking <Token>ETH</Token> price first thing in the morning. Doing health factor math during lunch. Setting price alerts on [CoinGecko](https://coingecko.com). Getting woken up at 3am because <Token>ETH</Token> dropped 8% during Asian hours and we're drifting toward a threshold we're not comfortable with. Deciding whether to add more <Token>ETH</Token> to the position, repay some of the debt, or just hold and hope. Executing a transaction on a phone while still in bed.

This is baseline. Anyone borrowing against <Token>ETH</Token> over the past six months has done this dance multiple times. This is not what we signed up for.

The $4,500 we borrowed costs more than 3% APR. It costs attention we never budgeted for. We took <Token>ETH</Token> sitting in a wallet requiring nothing and turned it into something that needs constant watching. Interest compounds while we're not looking. The exit window opens and closes without us. We traded simplicity for liquidity and got operational complexity as a fee we didn't know was part of the deal.

And some people [amplify all of this even further by looping](https://plug.to/posts/looping-on-aave), borrowing and re-depositing recursively for more exposure. Same concerns, higher stakes.

## Traditional Behaviors with Crypto Exposure

The promise is real. Borrowing against your crypto instead of selling it is one of the best financial tools available to anyone holding a meaningful amount of <Token>ETH</Token>. The tax efficiency alone makes it worth considering. Accessing liquidity without giving up your position in an appreciating asset is something traditional finance charges a premium for and requires a mountain of paperwork to get.

The implementation hands you a leveraged position and calls it a loan. We wanted cash now, pay it back later, keep the upside. We got a directional bet that can liquidate while we sleep. The mechanics work. The interface just doesn't protect you from them.

That gap is what [Plug](https://plug.to/app) closes. It sits between what the interface tells you and what the position is, turning intent into the [continuous management](https://plug.to/posts/programmable-ethereum-transactions-without-smart-contracts) the mechanics demand.

The biggest thing missing from our position is the thing every traditional loan has by default: a repayment schedule. Aave doesn't give us one, so Plug creates one. We set up recurring payments that chip away at the debt on a schedule we define, weekly, monthly, whatever fits. The same structure that makes a mortgage feel manageable instead of terrifying. Interest stops compounding against us because the principal is shrinking instead of sitting still. We get the psychological and financial rhythm of a normal loan on top of a position that was never designed to provide one.

The second thing missing is a clean exit. We set a price target on the upside, the point where <Token>ETH</Token> has appreciated enough that closing the position makes sense, and a floor on the downside, the point where we'd rather walk away with most of our collateral than risk liquidation. When either condition hits, the position closes itself. No 2am chart-staring. No panic decisions. The exit we'd choose if we could watch the market around the clock, defined once and enforced automatically.

At origination, Plug also compares borrow rates across <Token>USDC</Token>, <Token>USDT</Token>, <Token>GHO</Token>, and <Token>DAI</Token> and takes the cheapest option. The rate comparison we should have done ourselves but didn't.

The position gets repayment structure. The exit gets defined before we need it. The rate gets optimized at entry. We get the loan we came for.

Define the boundaries you're comfortable with. [The position manages itself](https://plug.to/app) within those boundaries while you go back to your life. That's what borrowing against your crypto should have looked like from the start.


DeFi borrowing looks like lending but operates like a leveraged position, and the gap between those two things is where people lose money....

Directional Leverage Dressed as Consumer Loans.



As a builder, I set off believing that building a pipeline to fetch the metadata for every crypto asset was going to be simple. Make a few onchain calls and we'd be done.

Token metadata had felt like a solved problem to me for years.

Names, symbols, decimals, images. A few RPC calls, some JSON parsing, a database table, and a cache. Nothing about it is costly or confusing, and most engineers have done this work before.

You wire it up, test it locally, and it works on the token you're using to test. Metadata resolves, images load, tokens render correctly in the UI. When something doesn't, it's easy to dismiss as a strange contract or an edge case you'll come back to later. <Token>MKR</Token> was deployed before [ERC-20](https://eips.ethereum.org/EIPS/eip-20) even existed, but that's a problem for future you. The rest of the product moves forward assuming this layer exists and behaves.

For us, this assumption held right up until our very first user appeared. Turns out, getting metadata for every crypto asset that exists is not simple. It's not even close.

The ERC-20 specification defines a `name()`, a `symbol()`, and a `decimals()` function. In practice, it guarantees none of them.

<MetadataSpec></MetadataSpec>

Contracts deployed before the standard was finalized return `bytes32` instead of `string` for `symbol()`. Others omit `decimals()` entirely because it was never a required function. Proxy contracts change their implementation behind a stable address, breaking cached ABI assumptions without warning. Some contracts revert on metadata calls unless the caller is whitelisted.

None of these examples are hypothetical. These contracts hold liquid value and show up in user wallets. A metadata system either handles them or displays nothing.

Handling them means special-casing. Every special case is a conditional branch in your ingestion pipeline that exists permanently, because the contracts it targets will exist permanently. The number of edge cases only grows.

And it's not a handful of tokens. Anyone can deploy a token contract at any time on any chain. There is no registry, no approval process, no way to know in advance which contracts your users will hold. The surface area is unbounded and grows continuously. Metadata has to resolve for whatever shows up, the moment it shows up, with no prior knowledge that it exists.

The obvious response is to throw more resources at the problem. More workers, larger queues, higher rate limits, more aggressive retries. Costs increase, latency improves slightly, and the system looks a bit healthier. But by the time you've invested real resources into keeping metadata responsive, the product has started to depend on it. UI components assume it will be there. Portfolio views assume it will resolve quickly. Features are written as if metadata is cheap and fast and always available, because you've made it expensive enough for that to usually be true. What was specced as a vanity feature is now load-bearing.

## Nonfungible Metadata Is a Different Problem Entirely

Eventually you'll find that many of your users hold NFTs. Major protocols like [Uniswap still use NFTs for their liquidity positions](https://support.uniswap.org/hc/en-us/articles/20980786685069-Why-is-liquidity-position-ownership-represented-by-tokens-or-NFTs), so choosing not to support them means choosing to deliver half an experience.

NFT metadata is structurally adversarial.

Every ERC-721 token exposes a `tokenURI` that points to a JSON document describing that specific token. Where that URI points is entirely up to the contract deployer. [IPFS](https://about.ipfs.io/). [Arweave](https://www.arweave.org/). [An HTTP endpoint](https://docs.opensea.io/docs/metadata-standards). [A base64-encoded data URI containing a raw SVG like Art Blocks uses](https://www.artblocks.io/). Each resolution path has its own failure mode, latency profile, and infrastructure requirements.

[IPFS gateways are unreliable, rate-limited, and slow](https://community.cloudflare.com/t/ipfs-gateway-rate-limiting/313015). Public gateways throttle aggressively under load. Private gateways require pinning infrastructure you now have to operate. Arweave is more stable but resolves differently. HTTP endpoints go down, change their response format, or disappear entirely when a project shuts down. Onchain SVGs need to be decoded, rendered, and sanitized against embedded scripts.

Of all nonfungible tokens we've indexed, 43% no longer resolve to any data. When a request does succeed, the JSON isn't enforced by the standard. Contracts return `image`, or `image_url`, or `animation_url` with no image at all. Others nest the image three levels deep in a custom schema. Some return HTML. Some return nothing.

<MetadataRetrieval></MetadataRetrieval>

ERC-1155 introduces a token type system on top of this, with a URI pattern that uses `{id}` substitution. A single contract can hold thousands of token types, each with different metadata, resolved through the same URI template. The metadata for token ID 1 and token ID 10,000 may live in completely different places, returned by the same function call with different parameters.

Dynamic NFTs change their metadata based on onchain state. A gaming NFT that levels up. A generative piece that evolves. The cache is wrong the moment the state changes, and there's no reliable signal for when that happens.

Everything you built for fungible tokens (the queue, the cache, the retry logic) is wrong here. Different resolution paths, different failure modes, different invalidation requirements, and orders of magnitude more individual items to track.

You start to feel the scale of this problem once you realize every solution compounds with every other section in this post.

## The Same Token on Every Chain

A token exists on Ethereum. The same token, representing the same asset, also exists on Arbitrum, Optimism, Base, Polygon, and whatever launched last week. Different contract address on every chain, different deployer, sometimes different metadata.

<MetadataChains></MetadataChains>

There is no canonical registry that maps these together. Token lists attempt it, but they're maintained by volunteers, lag behind deployments, and conflict with each other. The Ethereum token list says one thing. The Arbitrum bridge says another. The project's own documentation says a third.

Bridged tokens add another layer. A token bridged through the canonical bridge has a different address than the same token bridged through a third-party bridge. Both represent the same underlying asset, with independent metadata, and both show up in user wallets.

The metadata system needs to understand that these are the same asset. Deduplication, canonical metadata selection, and conflict resolution across chains for contradicting data. When you're heads down getting one chain working, it's easy to write this off as an edge case. It isn't. This is every major token.

## Images Are Infrastructure

Once you've resolved a URI and parsed the JSON, you have an image reference. It points to a file you don't control, in a format you didn't choose, at a size you can't predict.

PNGs can be 50 megabytes. SVGs can contain embedded JavaScript. GIFs can have thousands of frames. `image` fields that point to MP4 videos, GLB 3D models, or other JSON documents are not uncommon.

You are now operating an image pipeline. Fetching from hostile sources, transcoding between formats, enforcing size limits, sanitizing SVG content, generating thumbnails at multiple resolutions, and caching the results behind a CDN that needs its own invalidation logic.

<MetadataImages></MetadataImages>

Every token without an image needs a fallback. The fallback logic is per-standard, per-contract, sometimes per-token. An ERC-20 with no image gets a generated icon from its symbol. An NFT with no image is just broken.

On top of this, every chain, protocol, and token list expects different image dimensions and formats. The same token on Ethereum uses a different image than on Arbitrum. The protocol's image doesn't match the token list's image. Neither matches what the user expects to see.

## Metadata That Doesn't Exist Until You Create It

Some assets have no metadata of their own because the concept doesn't apply to them the way a metadata system expects.

A Uniswap V2 LP token is an ERC-20 with a `name()` and `symbol()` that tell you nothing useful. To represent it meaningfully, you need to know it's a liquidity position, resolve the two underlying tokens, fetch their metadata, and composite an image that communicates the pair. The LP token itself has none of this information. You have to understand the protocol to construct it.

Yield vault tokens are similar. <Token>wstETH</Token>, <Token>cbETH</Token>, <Token>rETH</Token> are all wrappers around underlying assets. The meaningful metadata belongs to the thing inside, not the wrapper the user holds. Displaying the wrapper's metadata is technically correct and completely useless.

Aave debt tokens, Compound borrow positions, and staked derivatives all require protocol-specific knowledge to represent. The metadata system can't just read from contracts. It needs to understand the relationships between them, determine what a position represents, and synthesize something a user can actually interpret in realtime.

<MetadataDerivedImages></MetadataDerivedImages>

This is protocol interpretation at this point, not metadata resolution, and every protocol speaks its own language. This realization almost broke our team's appetite for solving it.

## Spam, Impersonation, and Trust

Every wallet on every chain is an open inbox. Anyone can send tokens to any address with any name, any symbol, and any image.

Scam tokens flood user wallets with metadata designed to phish. The token name is a URL. The image mimics a legitimate project. The symbol matches a real asset. A metadata system that faithfully displays what the contract returns is a metadata system that faithfully displays phishing attacks.

Token impersonation means name, symbol, and image are not identity. Two contracts with identical metadata can represent completely different assets, one legitimate and one designed to steal funds. Without a trust layer on top of metadata (verification status, community reports, contract analysis), the scam renders alongside the real thing and the user has no way to tell.

<MetadataSpam></MetadataSpam>

There is no universal signal for legitimacy. Token lists are incomplete, and the best practice is to not use one at all. Contract verification is voluntary. Social consensus is unstructured and constantly shifting. You just pick an approach and ship it.

## Freshness Has No Strategy

Metadata is not static, and this goes well beyond NFTs changing their images. ERC-20 tokens rebrand. Names, symbols, and logos shift without any onchain signal. ERC-4626 vaults expose a share price that changes every block. The `totalAssets` and `convertToAssets` reads that define a vault position's value are live computations, not cached values. Even `decimals` on a proxy token can change if the implementation is upgraded.

For fungible tokens, the "metadata" that matters to users (price, market cap, supply, balance) is entirely offchain or derived from state that moves continuously. None of it lives in `name()` or `symbol()`. For vault tokens, the fields that define the position (share price, APY, underlying asset, strategy allocation) require multiple contract reads that are only valid for the block they were fetched in.

Rebasing tokens make this worse. <Token>stETH</Token>, <Token>AMPL</Token>, <Token>OHM</Token>: the balance itself changes without a transfer event. `balanceOf` returns a different number every block even though no transaction touched the address. Yield-bearing tokens have the same problem from a different angle. Aave's aTokens accrue interest continuously via an internal index. Compound's cTokens use an exchange rate that drifts. Every cached balance is stale the moment it's rendered. There is no event to subscribe to, no callback to register. The state just moves underneath you.

<MetadataFreshness></MetadataFreshness>

When do you re-fetch? On user access, and you've introduced latency into every page load. On a timer, and you're wasting resources refreshing metadata that hasn't changed while missing updates that have. On onchain events, and you've built an event indexing system for a problem that was supposed to be simple.

Users expect a refresh button. That button implies an invalidation strategy per source, per standard, per chain. It implies you can determine what's stale, where the fresh version lives, and how to replace the cached version without breaking whatever depends on it downstream.

Realtime updates for standards that were never designed for them is a contradiction. ERC-721 has no event for metadata changes. ERC-4906 attempted to add one, but adoption is minimal. ERC-20 has no concept of metadata updates at all. ERC-4626 vaults emit deposit and withdraw events but nothing for the share price changes between them.

## The Incentives That Prevent Improvement

The companies that provide token metadata today are data providers. They sell API access to blockchain data as their core business. Their product is the feed itself.

This creates a structural misalignment. A data provider's quality bar is set by what customers complain about, not by what breaks their own product. When metadata is wrong or missing, the provider's app keeps running. The customer's app is the one that breaks. The feedback loop is a support ticket, not a crashed page.

Breadth gets prioritized over contextual accuracy. A provider can return metadata for a million tokens and consider the job done. Whether an LP token renders as a meaningful position or a vault wrapper surfaces its underlying asset is outside their scope. They return what the contract returns. What it means is your problem.

Every team building at the application layer ends up maintaining their own interpretation layer on top of their data provider's output. The provider handles resolution, the consumer handles meaning, and the gap between the two is where every product quality issue lives.

Plug exists on the other side of this gap. [Every input in a Plug sentence is contextual](https://plug.to/posts/programmable-ethereum-transactions-without-smart-contracts). When a user selects a token to swap, the options they see (balances, prices, protocol positions, underlying assets) are drawn directly from the metadata pipeline. When the metadata is wrong, the Plug is wrong. When a position isn't interpreted correctly, the user can't build the strategy they came for.

<AlphaOptions></AlphaOptions>

The metadata infrastructure behind Plug wasn't built to sell API access. It was built because our product doesn't work without it. The quality floor is set by whether a user can construct and execute a transaction that does what they intended.

The [Plug API](https://plug.to/api) exposes this infrastructure directly. Realtime balances, prices, DeFi positions, collectibles, and the token data needed to represent the actual state of a portfolio across every chain we support.

If you're building something that needs this data, [you can play with our interactive documentation here without having to download a thing](https://plug.to/api).


As a builder, I set off believing that building a pipeline to fetch the metadata for every crypto asset was going to be simple....

Getting Metadata for Every Crypto Asset That Exists.



<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/381e35). 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 against <Token>USDC</Token> on [Aave](https://aave.com).

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 against <Token>USDC</Token> 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. 

The problem is that 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 was 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.

## Capture Upside on Your Aave Loops with Plug

Calling the direction is only half the trade, capturing your upside is the other. Of course there's no perfect formula for the latter, but, you don't need to worry about value leaking anymore. 

[Plug](https://plug.to/app)'s trailing stop constraint captures upside on your leveraged positions as soon as the moment presents itself.

One intent reacts to live onchain state and handles everything for you. Entry. Rebalancing. Exit. All of it constrained to your target health factor and trailing stop. So once you're in the loop, your upside stays open, and when the trend breaks, you exit with gains locked. 

Ready to try it? Head to the app to run our curated looping plug.


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/plugdotteeoh) 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/381e35). 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....

Programmable Ethereum Transactions Without Smart Contracts.

An app to build and run complex transactions

A backend to plug-and-play