01
Self-Custodial Agentic DeFi Platform (opens in a new tab)
An on-chain investment desk you talk to in plain language. You say what you want, it turns that into orders, and your funds never leave your own wallet.
HOW IT WORKS
An AI layer with a financial harness and custom-built tools translates natural language into orders. Users grant tightly scoped delegations from their MetaMask wallet through ERC-7702, ERC-7710 and ERC-7715. Other wallets are supported with Permit2. The AI never holds funds or keys and never controls a transaction. A portfolio module shows positions and performance.
The problem
My first trading engine worked, but nobody wanted to hand their private key to an application. And even with the trust problem solved, placing on-chain orders was still too technical for most people. This project answers both. It applies everything I learned from the trading engine, makes it self-custodial, and lets users drive it with natural language.
Architecture
Users type what they want: "sell my ETH at 4000", "buy ETH at 2000", or "set a trailing stop loss of 10% on token X". The AI is a translation engine from natural language to orders. It runs inside a financial harness with custom-built tools, so it is financially literate, and each tool maps a request to the matching order or delegation. Custody is handled by account abstraction. With ERC-7702, ERC-7710 and ERC-7715, a user grants tightly scoped delegations from their MetaMask wallet. The AI does not control any transaction, any funds or any private key. A portfolio module gives users a clear view of their holdings. The application runs on Base and Robinhood Chain.
Hard parts
The hardest part was the custody design: working out how to use account abstraction so the AI is useful without ever having control. The second was tailoring the brain. A general model is not a trading assistant. I learned how LLM tools work and how to build them, then shaped the harness and tools until requests turned into the right orders every time. The portfolio module was the third. Getting balances, positions and performance correct across chains was harder than it looks.
Outcome
The application is in private beta while full support is rolled out. It brings my earlier work together: the trading engine, the on-chain data pipelines and the AI layer in one product that a non-technical user can trust with their own wallet.
Multi-DEX Trading App
One trading interface over many DEX protocols on many chains. It adds limit orders, stop-losses and route aggregation to DEXes that do not support them natively.
HOW IT WORKS
An ethers.js layer puts each protocol behind one adapter interface. The routing engine quotes all adapters and picks the best. Limit orders live off-chain and fire at the target price. The Next.js UI is served as a single-page app from an Express backend.
The problem
It started with a simple frustration. I bought a token and could not easily sell it at the price I wanted. Why can't I sell token Y at price X? Most DEXes have no limit orders, so you either watch the chart or miss the price. I went down the rabbit hole to solve that for myself, and it became my start in DeFi automation.
Architecture
The engine is a fullstack trading application that runs locally in Docker. A Next.js UI is served as a single-page app from an Express backend. You give it a private key and an RPC endpoint, and it lets you place your own limit and stop-loss orders. At its core is a transaction encoding layer that builds the calldata for each DEX router. Every protocol sits behind the same adapter interface, so the rest of the system does not care which DEX or which chain it trades on. The routing engine quotes all adapters and picks the best one. Orders live off-chain and fire when the market reaches the target price. It supports Ethereum, Arbitrum and Base, and trades on Uniswap, SushiSwap, Aerodrome and PancakeSwap across their v2, v3 and v4 versions.
Hard parts
This was my learning project, so everything was a hard part once. What is a smart contract, really? How does transaction calldata work? How do you craft a transaction by hand, and how does each DEX router expect it? The real challenge was the last step: taking routers that all work differently and unifying them into a single interface that is simple to trade on.
Outcome
I ran about 200 trades through the engine and it worked as expected. When I tested demand, I found the real blocker was not the technology but trust: people did not want to give an application their private key. The engine is no longer running. That lesson shaped what came next, a self-custodial on-chain investment desk that keeps the trading engine and solves the trust problem with account abstraction.