Oh, It's Like Glider?

We already trust financial products to manage a basket of assets for us. In TradFi it's a sector fund we buy once and never have to tinker with again. Onchain, it's a token that wraps a whole index into a single position. Reserve's DTFs do it today with token baskets that rebalance to their target weights right onchain, and Alongside did it before them with a market-cap-weighted basket of the top crypto assets. We buy the token, someone else maintains the mix, and we get to own a portfolio without babysitting it.

Glider takes the next step and hands us the wheel. Instead of buying someone else's index, we choose our own basket and how it's weighted: everything equal, a percentage we type for each token, or weighted by market cap so the top assets carry more. We pick one of the three, sign once, and our basket holds that shape through every swing. For a while, Glider gave me the best hands-off portfolio experience I’d had, and that was enough for me.

But over time I craved more flexibility and control. I wanted weights that answer to the market instead of a number I typed on a Tuesday and forgot about. I wanted my protocol positions rebalancing alongside my spot holdings. Ultimately, I was reaching for an all-encompassing portfolio that could think and act as I would if I could always be there. But when I reached to express all the behaviors I wanted, I kept hitting walls.

Glider is one superhero, and it’s genuinely great at its one power: weighted spot rebalancing. Plug, on the other hand, is the whole roster, with every cape on the rack, where I can have any rebalancing hero I want. Today, everything Glider's app does can live in a plug. And there’s a shelf of other plugs beside it that can rebalance anything else you hold onchain.

You’re probably wondering how that’s even possible, so we’re right on track. Keep on reading.

Having a portfolio that thinks and acts like we would very simply comes down to being able to express our intentions onchain. This is Plug’s bread and butter.

On Glider, expressing logic is a bit different, and there’s a ceiling. Let’s start with the one number I could never make my own on Glider: the literal, static weight value they prompted me to select or type in.

The first piece of logic I wanted was simple. I wanted my token weights to react to prices, so I could lean more into when it dips and ease out when it runs. Buy low, sell high. I figured there had to be a way to make Glider’s weights move on their own, so I went looking. And to Glider's credit, there is a nuanced version of that. You build a portfolio with blocks, and one of them is the If/Else block.

An If/Else block takes two signals, something like current price, market cap, volume, or a moving average, compares them with a greater than or a less than, and when it comes back true, switches you to a different allocation you set up in advance. So Glider can absolutely watch and react when it moves. That part is real, and I want to be fair about it.

But here is where I hit a wall. Every allocation an If/Else block lands on is another set of weights I had to type by hand. The block never works anything out for me, it chooses between options I already built and hands me one. So the moment I wanted a weight that dynamically tracked price, I would have to pre-build an allocation for every price level I cared about, for every token in the mix.

Two tokens and a few levels each is already a dozen allocations by hand. Add a third token, or add more constraints, and the count climbs into the hundreds and then the thousands, and I would be hand-building forever to cover ground that a formula could walk in one line.

At this point, I realized how many walls there were, all because I couldn’t express the precise logic I wanted. I wanted a weight that computed itself from where price actually sat, instead of one I picked from a list. I wanted my basket to count the exposure I already had from a leveraged position, instead of piling fresh spot on top of it.

But Glider only ever knew about my spot tokens, their portfolio builder couldn’t work out a new number, and it had no idea whether I was leveraged or borrowing against anything. So for a while, I let my dreams go and settled into the belief that my portfolio could only do what their app let me express.

That belief lasted longer than it should have, especially for someone who works on Plug. I knew what we'd built, I just hadn't turned my focus to breaking these walls down yet. But once I did, my world opened up.

I decided to start at the floor. Before I chased any of the spot or protocol logic Glider wouldn't let me express, I wanted to rebuild the one thing Glider is genuinely great at, weighted spot rebalancing, as a plug of my own with one core job: set a basket of tokens and rebalance them to their target weights.

Glider is an app that a whole company was built to ship. But on Plug, their entire product is a single plug you can fork and own in a minute. Here it is, the whole app, as one plug.

It reads my live holdings and the live price of every token in the basket, works out how far each one has drifted from its target, and trades me back into line. And when you open it up, it comes down to three small pieces: the one that rebalances my holdings to their targets, fed by two simple reads for what my portfolio is worth right now and what each token's target should be.

My "plugs are apps" thesis I’ve been shouting for a year is finally starting to prove itself. Glider's walls were real yesterday, gone today, and the floor I just rebuilt is where everything else gets to stand. From here, every wall I hit starts to come down one at a time. And the first one to fall is the static weight input.

On Plug, an input doesn’t have to be a literal, static value. Look at those three pieces again. When the plugs run, they read my live balances and the live price of every token and compute each target right then, fresh from the chain. The only constraint I typed by hand was the weight. But I didn’t even have to do that.

The weights are inputs exactly like the prices and the holdings, so they can be computed just the same. So I built a small plug that reads a price signal and hands back a weight. Here it is:

It takes a token, works out a simple moving average of its price, and divides that average by the live price to land on the weight. So now when trades under its recent average the ratio climbs and the plug leans in, and when it runs above the ratio falls and the plug eases out. Buy low, sell high, written as a formula that runs itself every time the plug does.

And the average underneath it is mine. Glider reads its price signals from DEX Screener and pays a hefty monthly premium for that offchain feed. My plug reads Chainlink right onchain and keeps its own history in plug storage. The signal my weight answers to is built from data I hold myself.

The window is mine too. Set it to any number and the average stretches or tightens to match: a slow read over thirty days or a snappy one over three. Glider’s moving average rides on the window its feed hands back, mine is a constraint I set, right beside the tokens and everything else I already own.

The rebalancer keeps the same shape it had before. The core thing that changes is the weight. In the fixed-weight version I typed a number into each token’s slot. Now, that slot is coiled to the computed weight thanks to one Get Weight Target per token run down the basket, each reading the same 9-day window I set once up top. The holdings and prices were always read live from the chain, and now the weight is too, so the whole basket answers to the market on its own instead of to a number I typed on a Tuesday.

Now back to my earlier point: “having a portfolio that thinks and acts like we would very simply comes down to being able to express our precise intentions onchain.” If you can describe a behavior, you can make it happen on Plug. Which means we can start tearing down more walls.

The token rebalancing plug handled the spot sitting in my wallet, but what about my leverage loop on Morpho?

I wanted my Morpho loop to have its own rebalancing logic that kept my assets safe. I’ve done this for my Aave positions before, but this time, I didn’t even need to put in any effort to get the behavior I needed.

My teammate had already shipped a Morpho leverage manager plug that keeps your position healthy by rebalancing it to a target LTV. I forked it from Discovery in one click, and it started running right alongside my token rebalancer.

Two plugs, two separate jobs, and on Plug they became two parts of one portfolio that rebalance in parallel. Glider would never even see a position like this. Another wall torn down.

And these plugs can do more than run side by side. If my basket ever held the same asset as my leverage loop, my token rebalancer could read the loop's position, subtract the exposure it already holds from that token's target, and floor the result at zero. A read and a subtraction, coiled into the token rebalance I already run, so it buys nothing when the loop already covers the target and never piles fresh spot on top of exposure I already had. My plugs hold different assets, so there’s nothing to trim today, but the dynamic behavior is the point, and it’s one Glider never gave me.

Here I was, rebalancing my spot tokens by weights that answer to the market and my leveraged position to a safe LTV, when I reached for one more type of rebalance behavior: markets themselves.

If my debt was sitting in a pricey Morpho market that made my loop too expensive to carry, I wanted it to move itself into a cheaper one the moment a better rate opened up, first checking that the new market had the liquidity to take it and that my position would stay healthy there. In this setup, I decided to steer by health factor, the number I'd leaned on through every Aave loop, instead of LTV. And that’s okay, we can constrain our rebalances to whatever signals we prefer.

To unlock this, my Morpho market refinancer used a whole fleet of plugs working together, comparing rates across markets, ensuring there’s liquidity and it’s safe to move to the target market, and refinancing the position on its own using flash loans. I already built that fleet, and you can walk through every piece in Building a Fleet of Plugs to Sail the Morpho Blue.

It runs on the same principle as everything before it. Plugs that are aware of each other, dynamic values computed live, just pushed further than I thought I could take it when I started this journey.

Today, the no's that walled me in are all yeses. A weight that follows price. A leveraged position that rebalances alongside my spot. A loan that moves itself into a cheaper market. Every one is a plug I can own instead of a feature I wait on a company to ship. All of it moving the way I would, even when I can’t be there myself.

Once I'd built a single behavior no other app would hand me, my old world looked small, and I couldn't go back to it. I let go of the idea that a portfolio has to be constrained, because I truly own it now, and I decide what my money does instead of living inside limits someone else set.

What comes next feels inevitable: an exponential moving average that counts recent days heavier than the rest, one built on trading activity instead of a token's price, tokenized equities rebalanced right alongside crypto positions, weights that lean on what a curator or a counterparty is doing. And the list does not end there, because plug logic is arbitrary, so if we can express a behavior, we can make it happen.

Today we can build what no portfolio company ever shipped for us. When someone sees what you forked or made and asks how, the answer is a plug they can fork too. Every no you turn into a yes makes the next one easier, and the roster of heroes keeps growing for all of us.