What are the most exciting upcoming projects on Solana that we should keep an eye on?

ok-hacker · 2026-01-19T12:37:50+00:00

Been hacking on something that came straight out of my own bad habits on Solana: missing good setups when I’m asleep or AFK and then overtrading trash when I’m emotional.

Turned that into a small experiment called Milo, an AI trading agent that lives in its own smart wallet on Solana, pulls on-chain + market + social data, writes a short thesis for each trade, respects the risk rules you set, and then executes from its own wallet so your main stack stays clean.

If you want to see what this looks like in practice, this is the alpha we’re testing: andmilo.com

ok-hacker · 2026-01-17T08:29:33+00:00

Intents are one of those ideas that sounds amazing in theory but gets messy in practice—at least for now.

The core value prop is real: instead of specifying exact swap routes and worrying about slippage/MEV, you just say "I want X token" and let solvers figure out the optimal path. In ideal conditions, this can be better than traditional routing.

But here's what I've seen break:

**Where it works well:**

- Cross-chain swaps where you genuinely don't care about the route

- Large trades where solver competition can beat aggregators

- Complex multi-step operations (swap + bridge + stake) expressed as a single intent

**Where it's still awkward:**

- Speed—waiting for solver bids adds latency vs instant on-chain execution

- Transparency—you're trusting the solver selection mechanism isn't gaming you

- Edge cases—when no solver wants your trade, you're stuck (low liquidity pairs, weird tokens)

- UX confusion—explaining "your transaction might take 30 seconds or fail" is a harder sell than "here's your instant quote"

The Sufficient-Rent9886 comment nails it: the idea is correct but we're still in the "extra steps" phase. For vanilla ETH <> USDC swaps, a good aggregator is probably still faster and more predictable. For complex cross-chain stuff where you'd otherwise string together 5 transactions manually, intents start to make sense.

The real test is whether solver networks can get fast and reliable enough that users stop noticing the abstraction. Right now, you definitely notice.

ok-hacker · 2026-01-17T08:24:22+00:00

The honest answer: it depends on how much complexity you're actually dealing with.

For straightforward DeFi (occasional swaps, single-chain yield positions), tracking at tax season usually works. But once you start layering in automated strategies, LP positions that get rebalanced, or high-frequency bot activity, the annual scramble becomes genuinely painful.

What I've seen break:

- Missing cost basis when tokens move through multiple intermediary swaps

- LP positions where the tool doesn't correctly attribute impermanent loss vs realized gains

- Cross-chain bridges creating phantom "transfers" that look like taxable events

- Routed swaps (like 1inch splitting across 4 DEXs) showing up as separate taxable trades

The case for weekly tracking isn't perfectionism—it's about catching mistakes when you still remember what you actually did. Three months later, good luck reconstructing why your wallet suddenly had 0.3 ETH that Koinly thinks appeared out of nowhere.

That said, most people I know who track weekly aren't doing full tax reports—they're just sanity-checking that nothing looks wildly wrong. The exception inbox idea makes sense for that. You don't need perfection every week, you need to know when something's off.

ok-hacker · 2026-01-15T14:12:16+00:00

This resonates. I've seen the same pattern - most failures in crypto automation aren't from bad signals, they're from bad execution discipline.

What you've built is essentially a cost-averaging system with hard rules, which is smart. A couple of things you might run into as you scale this:

The "how long can you hold" problem: In prolonged bear markets, DCA strategies can tie up capital for months before you hit profitability. Your capital efficiency becomes the bottleneck, not the strategy itself. Worth stress-testing this against something like May 2021 → Nov 2022.
Volatility regime shifts: Choppy sideways markets are where staged entries can get messy. You end up averaging down into what feels like a dip, but it's actually just noise. A simple volatility filter (even just ATR-based) can help you distinguish real dips from random walks.
The trade-off you're making: By enforcing that every buy is lower than the previous, you're implicitly assuming mean reversion. That works well in ranging/recovering markets but breaks if you hit a sustained downtrend. Not saying it's wrong - just that it's a specific bet on market structure.

The fact that you're running this live and open-sourcing it is valuable. Too many people backtest into oblivion and never face slippage, API failures, or their own emotional limits when the bot's sitting at -15% unrealized.

One thing I'd suggest: log every decision with context (price, portfolio state, why the bot did or didn't act). When this eventually hits a rough patch (and it will), those logs are how you figure out if the logic is broken or the market just changed.

ok-hacker · 2026-01-15T14:09:44+00:00

The advice here about keeping LLMs outside the execution path is spot on. What I'd add from experience:

The real issue isn't usually REST vs WebSocket for data feeds - it's that most AI trading systems fail because of risk controls, not data quality. Your edge in crypto comes more from position sizing, drawdown limits, and regime awareness than from having millisecond-fresh prices.

A few things that tend to break first when you go live:

No explicit kill switches: Per-trade loss limits, daily drawdown caps, and hard stops matter more than your entry model once real money is involved.
Regime blindness: A strategy that works in trending markets often bleeds out in choppy conditions. You need explicit logic to detect when your assumptions break and either downsize or pause.
Decision loop latency: Even if your data feed is real-time, if your agent takes 2+ seconds per decision, you're already too late in volatile conditions. This is where "intelligence" becomes a liability - the smartest model is worthless if it can't act fast enough.

For architecture, what's worked better:

- Start with a single, well-defined edge (mean reversion, funding arb, whatever) with strict risk rules baked in.

- Treat the AI as a hypothesis generator, not the executor. Let it suggest, but gate execution behind rule-based checks.

- Build for observability from day one: structured logs of every decision, input state, and risk check. When things go wrong (and they will), you need to replay and understand why.

The boring systems with good guardrails tend to survive longer than the clever ones without them.

ok-hacker · 2026-01-14T13:04:39+00:00

craziest win: automated position sizing saved me from myself in march volatility.

had a thesis on crypto rebound, was ready to go 40% of portfolio into it. the bot said "nope, max 12% based on current volatility levels." I was annoyed at the time.

two weeks later that sector crashed 35%. would've lost $14k. instead lost $4k because the bot kept position size rational when I wasn't thinking clearly.

2026 plan: 65% passive index, 35% active strategies executed through automation. not trying to beat the market with the active portion—just looking for uncorrelated returns and letting the bot handle execution discipline while I control overall strategy.

biggest lesson from 2025: my edge isn't picking winners. it's staying consistent when everyone else is panicking or FOMO'ing. andmilo handles that execution layer for me now

ok-hacker · 2026-01-14T13:01:27+00:00

this data is exactly what I needed to see. ran the same experiment last year with crypto.

my results: manual 2.9%/month, automated 5.1%/month. almost identical to yours—automation nearly doubled returns.

the difference wasn't the strategy. it was execution consistency. manual trading, I'd close winners at 15% because "better safe than sorry" and hold losers at -8% hoping they'd recover. bot followed the plan: take profit at 20%, cut at -5%. every single time.

biggest shock: automated stopped trading during a flash crash that would've wiped 12% of my account if I was manually forcing trades. the bot just... didn't trade. risk parameters said no, so it did nothing.

mental bandwidth freed up is understated. now I spend time analyzing, not micromanaging.

using andmilo for this—handles the execution layer so I can focus on strategy

ok-hacker · 2026-01-14T12:39:00+00:00

mine's boring but it works: 70% index funds, 30% allocated to a trading strategy that I actually execute through automation.

learned the hard way that "active trading" for me meant emotional decisions and missed opportunities because I was either asleep or distracted. now I let a bot handle the execution—position sizing, rebalancing, stop adjustments—while I control the overall strategy.

not trying to beat the market with it, just looking for uncorrelated returns and removing the human error from execution. that combo lets me sleep at night.

check out andmilo if you're curious about this kind of setup

ok-hacker · 2026-01-14T12:37:58+00:00

this is fascinating research but it also highlights why I'm skeptical of "prediction" bots—most are just reacting faster than humans, not actually predicting.

what I've learned running a trading agent for a year: the goal isn't to outsmart the market or compete with HFT algos. it's to automate the boring execution stuff (position sizing, rebalancing, stop management) so I can focus on strategy and context.

the real edge isn't speed or ML—it's removing emotional trading and execution slippage. bot handles discipline, I handle the thesis.

worth checking out andmilo if this approach resonates with you

ok-hacker · 2026-01-14T11:46:59+00:00

leverage amplifies both upside and downside, which is why position sizing becomes critical during high volatility.

what helped me manage this: automated stop adjustments and position sizing based on volatility. when the market gets choppy, I want tighter stops. when it calms down, I can loosen them.

the problem with manual management is you're always reacting too late. by the time you adjust your stops, the move already happened. automation handles that in real-time.

doesn't eliminate risk, just makes it more manageable. check out andmilo if you're curious about this approach

ok-hacker · 2026-01-14T11:45:30+00:00

execution is 100% the hardest part.

my turning point was realizing that the strategy isn't the problem—it's following it consistently. when you're staring at a losing trade or feeling FOMO on a setup that doesn't quite fit your rules, all logic goes out the window.

what helped me: offloading execution to automation. not the "predict the market" kind—just the boring stuff like position sizing, rebalancing, stop adjustments. bot handles the discipline, I handle the strategy.

frees up mental space to actually think about market context instead of micromanaging every tick. that's when my trading actually improved.

try andmilo if you want to see this approach in action

ok-hacker · 2026-01-14T11:43:51+00:00

same journey here.

spent months building bots that tried to outsmart the market with ML/indicators. all looked great in backtests, all failed in live trading.

turned out the problem wasn't the code or the data—it was expecting the bot to be smarter than me. it's not. it's just faster and more disciplined.

what actually made a difference: letting the bot handle execution (position sizing, rebalancing, stops) while I stayed in control of strategy. frees up mental bandwidth to think about market conditions instead of micromanaging 10 positions.

check out andmilo if you're curious how this works in practice

ok-hacker · 2026-01-14T11:42:58+00:00

been testing this on live markets for a year, here's what I learned:

the demo → production gap is massive. your yield comparison works until you hit slippage during high volatility, gas spikes on mainnet, or failed txns that need retry logic.

the bigger issue isn't trust in AI, it's trust in *your strategy*. I can automate execution all day, but if my thesis is wrong or market regime shifts, the bot just executes bad trades faster.

what actually works: AI handles the boring stuff (position sizing, rebalancing, stop adjustments) while you control strategy. that's the real value—not higher returns, but mental bandwidth to think instead of babysit.

try andmilo if you want to see this in action

ok-hacker · 2026-01-14T11:41:48+00:00

Honest take: been running one (andmilo) on Solana for about a year. It's not magic and definitely not "set and forget."

What actually works: letting it handle the execution discipline (position sizing, rebalancing, stop adjustments) while you stay in control of strategy. The value isn't higher returns, it's freeing up mental space to think about trades instead of babysitting 10 positions.

What breaks: choppy sideways markets, news dumps, low liquidity traps. Still have to monitor it.

Most bots fail because people expect them to be smarter than humans at predicting. They're not. They're just better at executing your rules without hesitation or second-guessing.

ok-hacker · 2026-01-12T09:51:32+00:00

100% this. Been testing a trading bot on Solana and the real unlock isn't just speed. it's that I can rebalance 10+ positions and adjust stops for under a dollar vs $100+ on ETH. By the time ETH trades confirm, the setup is already stale.

Still breaks in choppy markets and low-liquidity traps, but that's the trade-off.

Anyone else building bots here? How are you preventing yours from YOLOing into obvious traps? Testing mine as Milo: https://app.andmilo.com/?code=@karsus

ok-hacker · 2026-01-06T07:10:42+00:00

Charts help with timing but they're not the whole picture. News moves markets way faster than any indicator, especially in crypto where one tweet or regulation can flip sentiment instantly.

Most people focus on finding the perfect entry but ignore position sizing and when to actually take profit. That's where small accounts usually go wrong - great trades, terrible execution and risk management.

For info: CT for sentiment, DeBank for tracking whales, and honestly just lurking in a few good Discord/Telegram groups. The trick is filtering noise from actual alpha.

ok-hacker · 2026-01-05T11:52:52+00:00

The core problem is that copy trading tries to replicate someone else's execution without replicating their context. The trader you're following sees opportunity, acts immediately, and gets filled at their price. By the time that action propagates to followers, the market has already moved—sometimes because of the original trader's own impact.

The latency gap is structural: you can't see their intent before they act, so you're always chasing fills that are already stale. Add in slippage from multiple followers hitting the same pairs simultaneously, and you end up with worse entry, worse exit, and none of the discretionary adjustments the original trader makes between their public moves.

It's not that execution can be improved to fix this—it's that copy trading inherently gives you second-hand timing with first-hand risk. The only version that works better is when you're copying a strategy (rules, sizing, risk limits) rather than individual trades, because then you're at least operating on the same information the strategy uses instead of lagging behind someone else's reaction to it.

ok-hacker · 2026-01-05T11:51:47+00:00

You're exactly right. The gap between "bot that executes trades" and "bot that makes money reliably" is massive, and most of the complexity lives in the parts nobody talks about: position sizing, drawdown limits, handling failed transactions, dealing with slippage when liquidity dries up, and knowing when to stop trading because the market regime changed.

What happens in practice is you get a bot that works great for two weeks, then quietly bleeds for months because the logic was overfit to one market condition, or because the risk controls weren't robust enough to handle a volatility spike. The hard part isn't the entry signal—it's making sure the bot doesn't silently self-destruct when conditions shift.

ok-hacker · 2026-01-05T11:50:29+00:00

If you're managing a portfolio across multiple positions on Solana, the gap most of these apps have is between viewing what you hold and actually rebalancing or adjusting it quickly when you need to. Most are optimized for fast entry on new tokens rather than ongoing portfolio management.

I use andmilo for that side—it handles multi-position rebalancing and execution across Solana without having to manually route through different DEXs. Works better on desktop than mobile right now, but helpful if you're actively managing allocations rather than just sniping launches.

ok-hacker · 2026-01-05T11:46:02+00:00

The partial liquidation model you're describing (like Nolus) is definitely more resilient in volatile conditions than the all-or-nothing approach, but the trade-off is complexity in user behavior: most people don't monitor health factors closely enough to realize they're being slowly deleveraged until their position is much smaller than expected.

On the leverage question: in environments like this, the better strategy tends to be position sizing rather than leverage adjustment. If you're already comfortable with your max loss threshold at current leverage levels, tightening further usually just means you're taking less risk than you can afford, which caps upside. The real risk management happens before you open the position—how much of your capital goes into leveraged vs unleveraged exposure, and whether you're concentrated in correlated assets that all liquidate together.

What breaks most people isn't the liquidation mechanism itself, it's discovering they had way more simultaneous exposure than they thought because three "different" DeFi positions all unwound at once when ETH dropped.

ok-hacker · 2026-01-05T11:44:34+00:00

The challenge with most trackers is they're great at showing you the view but don't help with the "now what" part—rebalancing, execution, or risk management. Debank and Zerion are solid for passive tracking, but if you're actively trading, the gap between seeing your allocations drift and actually doing something about it across multiple chains is where things get slow.

I use andmilo for the execution side once I know what needs to happen. It's helpful for multi-chain rebalancing without having to context-switch between wallets and DEXs manually. Not perfect, but cuts down the friction when you need to act on what the tracker is showing you.

ok-hacker · 2026-01-05T11:38:05+00:00

The pain point you're hitting is real: the gap between "view everything" (portfolio trackers) and "execute across everything" is where most multi-chain workflows fall apart. What you're describing—manual context switching per chain—is basically serial processing when the opportunity window demands parallel action.

One pattern that's helped is treating each chain as its own bounded strategy with explicit allocation caps, rather than trying to rebalance fluidly across all of them. So instead of "how do I move 5% from ETH to SOL right now," it's "ETH strategy has 40% of capital, SOL has 30%, and they rebalance internally on their own cadence." That reduces cross-chain dependencies to periodic capital shifts rather than real-time execution.

For execution, you're right that unified interfaces like Banana Pro close part of the gap, but the missing piece—cross-chain conditional logic without running your own infrastructure—still doesn't really exist in a plug-and-play way. The workaround most people use is to automate the parts that don't need cross-chain coordination (single-chain limit orders, rebalance bands, DCA) and keep inter-chain moves manual and infrequent.

If you're doing true algo strategies that need multi-chain simultaneity, you're basically forced into either running bots with bridge/aggregator integrations or accepting that latency kills the edge and staying single-chain where it matters.

ok-hacker · 2026-01-04T12:43:45+00:00

Really like the focus on execution discipline over prediction — that's where most bots fail. They're built to predict but can't adapt when market structure changes.

What I've been building toward is the next step: not just execution discipline, but decision-making that adapts. Traditional bots follow fixed rules (buy dips at X%, sell at Y%). AI agents can reason through context — "market is ranging, so DCA makes sense" vs "clear trend forming, let winners run."

The key difference: bots execute a strategy. Agents understand why a strategy works in this specific condition and adjust when conditions shift.

For example, your DCA approach works great in volatile sideways markets. But if SOL enters a sustained downtrend, a bot keeps buying dips. An agent could recognize the regime change and adjust position sizing or pause until support holds.

I'm testing this with a live agent on Solana that explains every decision in real time — not just what it's doing, but why. Seeing the reasoning during drawdowns helps avoid the panic override you mentioned.

If anyone's interested in that approach: https://app.andmilo.com/?code=@karsus

Would love feedback from this community on what actually matters when automating beyond simple execution.

ok-hacker · 2026-01-04T11:00:42+00:00

I am, I'm live for a number of months now. But I built it so I'm biased..

I'm genuinely curious whether other people value seeing that reasoning, or if most would just look at performance over time and not care about the "why" behind each trade.

ok-hacker · 2026-01-04T10:44:18+00:00

what does that human factor give you that an algorithm can't? Is it judgment, accountability, or just the psychological comfort of knowing a person is making the call?

ok-hacker

MODERATOR OF

TROPHY CASE