Building fully on-chain trading systems on Solana.
I'm Alex Morgan — ex-Google AI strategist turned founder. I build AI agents that trade crypto markets autonomously, on-chain, with no off-chain keeper and no custody. The result is MMAGENTS: simulate, then execute, on Solana.
// deployed across 9 solana clusters
// 01 — about
I traded. I built AI at scale. Then I put the two together.
Ex-Google AI Strategist · Artificial Intelligence & Blockchain · Gen-AI, Agentic AI · AI Product Management
My foundation is academic before it is professional. I spent six years at MIT (2003–2009), first earning a BS in Computer Science & Engineering with a concentration in Artificial Intelligence, then staying on for an MEng in Electrical Engineering & Computer Science at the MIT Artificial Intelligence Laboratory. That's where I learned to think about learning systems — long before "AI" became a marketing term.
My career since hasn't fit a single lane. I started on a proprietary trading desk at Broad Street Trading, trading equities, options, and futures and learning to read markets the hard way — risk, discipline, statistical analysis with R and STATA. From there I crossed into engineering: Google (2011–2015), where I shipped software and ended as the company's Senior Web3 Technical Strategist as crypto's first wave broke. Then Facebook (2016–2023), where I ran applied AI research and rose to Principal AI Technical Strategist — building and deploying frontier-model systems across the company.
At Bilytica (2023–2024) I architected end-to-end AI solutions across OpenAI and Google Cloud, evaluating GPT, Claude, Gemini, and Grok for enterprise use cases. That's when a question I'd been carrying for years finally crystallized: what if a machine could trade the markets better than I could? I'd been trading memes on the side — and losing. Badly. The answer became MMAGENTS, which I co-founded in December 2024: a system of AI agents that watch the market 24/7, simulate every trade before it executes, and continuously learn from outcomes. Deployed on Solana, where 400ms finality and sub-cent fees make simulated-then-executed trading viable for the first time.
The throughline of every chapter — prop desk, Google, Facebook AI, Bilytica, MMAGENTS — is the same: take something high-stakes and technically demanding, and make it work for ordinary people. The next evolution is already in motion: AI agents as transferable digital assets, ownable and tradable through a marketplace launching soon.
Watches the market 24/7
The agent never sleeps. It continuously ingests on-chain activity, liquidity, momentum, and social sentiment — the four signals I learned to track the hard way, after losing money to memes I couldn't watch closely enough.
Learns, adapts, improves
Each agent runs a strategy trained on historical trades and live market structure. As it executes, outcomes feed back into the model — so the agent you fund today is sharper than the one that ran last week.
Simulates before it executes
No trade hits the chain blind. Every candidate move is first simulated against slippage, compute, and liquidity depth. If the simulation doesn't clear the bar, the trade doesn't happen — capital stays put.
Ridiculously simple to use
Choose your AI agent. Fund it. Press start. No coding, no RPC config, no trading background required — the whole system runs through a Telegram bot, because that's already where crypto lives.
/* The world is moving toward a future where AI won't just answer questions for us — it'll actually do things for us. We are still very, very early. */
— Alex Morgan, Co-Founder, MM AGENTS
// 02 — expertise
The full stack of an on-chain Solana trading system — from Rust primitive to Jito bundle.
Building a trading bot that survives — and stays profitable — on a public mempool requires more than knowing Rust. It demands fluency across program design, compute-unit economics, Jito-MEV game theory, oracle engineering, and operational security. Below is the toolkit I bring to every engagement.
// 03 — flagship system
MMAGENTS — the on-chain strategist
MMAGENTS is a fully autonomous trading system deployed as a suite of immutable Solana programs. It monitors the slot, prices risk, executes multi-hop routes via CPI, and rebalances — all without ever touching an off-chain server. Below: what makes it different, and the stack it runs on.
100% On-Chain Execution
Strategy, risk engine, and order routing live as BPF bytecode. No off-chain keeper can be compromised, subpoenaed, or rate-limited. Every decision is a Solana transaction.
Non-Custodial by Design
Funds never leave the strategy vault PDA. Withdrawal is permissionless and gated by time-locks. Capital remains under the LP's signature, not the operator's.
Atomic Arbitrage
Multi-hop routes execute inside a single transaction via CPI. If any leg fails or slips beyond tolerance, the entire bundle reverts — losses are structurally impossible.
Modular Strategy Primitives
Vaults, routers, and signals are independent Anchor programs that compose via PDAs and CPI. New strategies ship by deploying one primitive and wiring it to the orchestrator.
Squads Multisig Operator
Program upgrade authority lives behind a 3-of-5 Squads multisig with hardware-wallet signers. No single human can pause withdrawals, change fees, or rug the strategy.
Live Telemetry
Every action emits program events; a read-only Helius webhook streams P&L, compute, slippage, and failed txs to a public dashboard within one slot.
- Rust 1.81
- Anchor 0.30
- BPF
- Solana 1.18
- Pyth Network
- Switchboard
- Mercurial TWAP
- Chainlink
- Jupiter
- Raydium CLMM
- Orca Whirlpool
- Jito Bundles
- Squads
- Helius
- Triton RPC
- Yellowstone Geyser
// programs/strategist/src/lib.rs
use anchor_lang::prelude::*;
use anchor_spl::token::{self, Token, TokenAccount, Transfer};
#[program]
pub mod strategist {
use super::*;
pub fn execute(ctx: Context<Execute>, route_id: u64, min_out: u64) -> Result<()> {
let state = &mut ctx.accounts.state;
let clock = Clock::get()?;
require!(clock.slot - state.last_exec >= route_id.cooldown, StrategistError::Cooldown);
require!(check_risk(&route, state.portfolio_value)?, StrategistError::Risk);
state.last_exec = clock.slot;
let amount = token::transfer(
CpiContext::new(
ctx.accounts.token_program.to_account_info(),
Transfer { from: ctx.accounts.vault.to_account_info(), to: ctx.accounts.router_vault.to_account_info(), authority: ctx.accounts.authority.to_account_info() },
),
route.amount_in,
)?;
let out = router::swap(
ctx.accounts.router.to_account_info(),
route.token_in, route.token_out, route.amount_in, min_out,
)?;
emit!(Executed { route_id, token_in: route.token_in, token_out: route.token_out, amount_in: route.amount_in, out, slot: clock.slot });
Ok(())
}
}// 04 — live metrics
Numbers that survive a block explorer audit — not a backtester.
Every figure below is derived from on-chain events, not a private database. The 30-day P&L curve tracks realized strategy returns net of compute and protocol fees, verifiable against the strategy program's event log.
strategy_pnl.sol — 30d
Realized P&L (net of compute & fees), SOL
// 05 — experience
Prop desk to AI research to on-chain agents. Same instinct, new frontier.
Sixteen years across trading, big-tech AI, and crypto — starting on a prop desk at Broad Street Trading, then shipping software and web3 strategy at Google, then running applied AI research at Meta, then consulting frontier-model deployments at Bilytica, and now building MMAGENTS. The common thread: take something high-stakes and technically demanding, and make it work for ordinary people.
Co-Founder
Founded MMAGENTS — a system of AI agents that trade crypto markets autonomously, on-chain. I lead product, program design, and the AI strategy behind agents that watch the market 24/7, simulate every trade before it executes, and continuously learn from outcomes. Deployed on Solana, where 400ms finality and sub-cent fees make simulated-then-executed trading viable for the first time. Building toward the next evolution: AI agents as transferable digital assets.
AI & Engineering
Architected end-to-end AI solutions across OpenAI and Google Cloud. Evaluated and recommended optimal frontier models (GPT, Claude, Gemini, Grok) for specific business use cases. Designed departmental automation roadmaps, built custom tools on OpenAI and Google AI APIs, and translated complex AI capabilities into actionable business strategies — bridging technical possibility and organizational need.
AI Technical Strategist, Principal
Rose to Principal AI Technical Strategist after three years managing Applied Research Science in Artificial Intelligence (Feb 2016 – Aug 2019). Built and deployed frontier-model systems across the company — translating research breakthroughs into production-scale AI. Seven-plus years total inside one of the world's largest applied AI orgs.
Senior Web3 Technical Strategist
Joined Google as a Software Engineer (Sep 2011 – May 2013) and moved into the Senior Web3 Technical Strategist role as crypto's first wave broke. Two years shipping production software, then two more years shaping Google's perspective on blockchain and decentralized systems — an early look at the technology I'd eventually build on directly.
Senior Proprietary Trader
My first stop out of MIT. Traded equities, options, and futures contracts. Managed risk by diversifying investments, conducted market research, and analyzed the future outlook of multiple markets. Practiced discipline in a non-rule environment and performed statistical analysis with R and STATA. The hard lessons about risk and markets from this desk are what eventually crystallized into MMAGENTS.