How Julien works.

A normal aggregator answers one question: what is the best price for the whole order right now. Julien answers two. What is the best price if the order is spread across the next N minutes, and what does the capital earn while it is still waiting.

Those are the two axes. UniswapX is the execution axis: each slice is measured against the Uniswap AMM baseline and the difference is booked as price improvement, in basis points and dollars. Morpho is the yield axis: capital that has not swapped yet sits in the highest-APY Morpho market for that asset, then comes out only for the slice that is about to trade.

A large market order pays for its own impact. The pool moves as the order lands, and the rest of the size fills at a worse price. Waiting without a plan is the other failure: capital sits idle and earns nothing for the length of the window.

Julien splits the order into TWAP chunks and refuses to leave the remainder uninvested. The window is not dead time. It is a lending position that shrinks, slice by slice, as the swap completes.

The terminal surfaces both results live. Price improvement is the gap between the AMM baseline and the fill. Yield is the interest accrued on whatever has not traded yet. Neither number is a promise about the next trade. Both are measurements of the run you are in.

Every run is the same five steps. The terminal walks them in order. You can see the active step along the bottom of the execution view.

1. 01Deposit. The full input goes into the Morpho market with the highest supply APY for that asset. Nothing is swapped on this step.
2. 02Monitor. Through the window, Julien polls Chainlink every 5 seconds over Alchemy. The feed is the clock and the reference, not the fill price.
3. 03Execute. At the slice time, Julien withdraws only that slice from Morpho and settles it through UniswapX, inside one transaction.
4. 04Repeat. The next slice waits for its own time. Each completed slice records price improvement in bps and USD. The rest keeps earning.
5. 05Withdraw. After the last slice, residual principal plus accumulated Morpho yield returns to the wallet.

TWAP here means time-weighted slices, not a special onchain order type. You choose the window and the number of slices. Julien divides the input evenly and assigns each piece a target time.

A one-hour run with four slices is the shape the terminal shows: a trade such as ETH into USDG, targets at 00:00, 15:00, 30:00, and 45:00. Slice one can go as soon as the run starts. The others wait. Julien does not pull the next piece early to "catch a wick," and it does not merge slices back into one market order if the first fill looks good.

Before a slice is signed, Julien takes two quotes for the same size. The baseline is the Uniswap AMM: the price you would get by routing that slice straight through the pool. The execution quote is UniswapX: an intent that says "sell this amount, accept no less than this output."

Price improvement is the gap between those two, expressed in basis points and then in dollars at the fill. A positive number means the UniswapX fill beat the pool. The terminal plots bps per slice against a zero line, which is the AMM baseline.

If UniswapX is not better, Julien does not fall back to the raw AMM for that slice. The rule is the same one the product is built on: protection is never best-effort. The slice stays unfilled until a quote clears the baseline, or the run ends and the remainder is withdrawn.

Capital you have not swapped yet does not sit in the wallet. After deposit, the full input is supplied to the Morpho market Julien selected for the highest supply APY. Morpho Blue tracks that position onchain. Julien reads it back rather than estimating interest off to the side.

Each slice withdraws only its own amount. The balance that remains in Morpho keeps accruing until the next slice, and then until the final withdraw. The yield figure in the terminal is that accrued interest, shown in USD, updating as the position shrinks.

The market can change APY during a window. Julien picks the market at the start of the run from the live supply rates. It does not hop markets mid-window, because moving collateral between markets would add signatures and break the slice schedule.

A slice is one transaction, not two. The Morpho withdraw and the UniswapX settlement are packed together, simulated, then signed once in Robinhood Wallet. If the swap cannot clear, the withdraw reverts with it. The slice's capital does not land in the wallet, idle, between a successful withdraw and a failed swap.

Count the signatures on a four-slice run:

Ten is the naive path: one deposit, four withdraws, four swaps, one final withdraw. Julien removes the four extra swap signatures by folding each swap into the withdraw that funds it.

UniswapX changes the thing you sign. An AMM swap signs a route: this pool, this path, this slippage. An UniswapX order signs an outcome: this input, at least this output, before this deadline. A filler — a market maker — competes to settle it, from inventory or from liquidity, and the route is their problem. If they cannot meet the minimum, the order does not fill and the funds stay put.

On Robinhood Chain that distinction matters less for sandwiches than it does on a chain with a public mempool. The sequencer orders transactions first-come, first-served. There is no public waiting room where a searcher can read your pending swap and buy the slot in front of it with a higher fee. Classic sandwich MEV, the front-run plus your trade plus the back-run, does not have a public pool to watch.

So UniswapX is not a second sandwich shield on top of the chain. It is how Julien gets a better fill than the AMM, and how it refuses a worse one. The chain removes the public-mempool sandwich. UniswapX is the price-improvement engine. Julien books that gap. It does not claim the filler, the sequencer, or the pool cannot still move the price.

Alchemy is the data path. Julien reads Robinhood Chain through Alchemy, simulates against that state, broadcasts the signed transaction, and waits for inclusion. There is no second RPC racing the first inside a slice.

Chainlink is the clock. Every 5 seconds during the window Julien polls the live price for the pair. That poll tells the terminal the window is still coherent: the reference has not gone stale, and the slice schedule still lines up with the market you started in. The fill itself is never priced off Chainlink. The fill is the UniswapX quote compared with the Uniswap AMM quote for that exact size.

Robinhood Wallet is the only signing surface. Julien uses it for the session, for the in-app connection, for simulation before broadcast, and for the batched slice. You approve a transaction you can read. Julien does not hold a session key that can move the position after you have closed the wallet.

Gas on Robinhood Chain is ETH. A slice that reverts in simulation is not offered for signature. A slice that reverts after broadcast returns the position to the state before that transaction, because the withdraw and the swap share it.

The execution view is three columns. The wallet column is the balances Julien can see for the session, for example ETH, USDC, and USDG. The center column is the order: pair, window, slice count, and the state of each slice. A slice shows its target time until it fills, then the bps it cleared. The analytics column splits the two axes: price improvement in bps, Morpho yield in USD, and a bar for each slice against the zero baseline.

Figures such as +11.9 bps or a yield of about twelve dollars are examples of the shape of a read, not a rate Julien owes you. Your run prints its own numbers from the quotes and the Morpho position.

Julien is four integrations and one schedule. Each partner has one job. None of them is swapped out mid-slice.

Julien does not invent liquidity. A thin pool on Robinhood Chain can still move when your slice lands, and UniswapX can only beat the baseline when a filler is willing to. Stock tokens and other RWAs on the chain can carry their own transfer and issuer rules. Julien will not route around those rules.

Julien is not an audited custody protocol, because it is not a custodian. It is a terminal that composes Morpho, UniswapX, Chainlink, Alchemy, and Robinhood Wallet. A failure in any of those is a failure in the run. The slice transaction is atomic so a failed fill does not strand a withdraw. It is not atomic across the whole hour: each slice is its own signed transaction, on purpose, so the rest of the position can keep earning between them.

The terminal is in final testing. This page is the behavior that testing is held to.