🤝 Top Collaborators
.png&w=640&q=75)
🤓 Latest Submissions
AlphaBeater
AlphaBeater is an autonomous trading agent built with LLM and Alpaca. It addresses a common problem with AI trading systems: language models can generate convincing ideas, but those ideas should not be trusted without deterministic testing and strict risk controls. The agent reads current market data (SPY, QQQ, and IWM currently) from Alpaca, summarizes price, volatility, and volume conditions, and asks an agent to produce falsifiable market hypotheses. Another agent then converts each hypothesis into interpretable expressions using AlphaBeater's constrained factor language. Regular Python code validates and calculates every expression without executing model-generated code. Candidates are evaluated using chronological training, validation, and test periods with transaction costs. The agent can reject every candidate and abstain from trading when results are inconsistent. Research-qualified strategies must pass performance, drawdown, liquidity, account, exposure, and maximum-loss checks. AlphaBeater also provides an explicitly labeled forward paper-experiment mode. This mode allows unvalidated candidates to collect genuine paper-trading evidence while keeping financial and operational safeguards active. During our end-to-end demonstration, AlphaBeater selected an IWM options contract, passed its applicable safety checks, submitted the order through Alpaca's official MCP server, received a fill, and monitored its live paper P&L. Every hypothesis, factor, backtest, decision, rejected check, order, and position update is stored in an inspectable audit trail. The result is not a black-box trading bot, but a transparent agent that can research, test, execute, monitor, and, importantly, decide whether to trade.
4 Sep 2026
QuantTrader
Most retail traders don't lose because they lack access to data. They lose because they don't understand it. Automated trading tools have existed for years, but they share a fundamental flaw: they're black boxes. A signal fires, a position opens, and the trader has no idea why. When volatility spikes and the system keeps buying into a falling market, panic sets in. They override it. They revenge trade. They blow the account. I built QuantTrader to fix that specific failure mode. The architecture is split into two deliberate layers. First, a deterministic Python engine handles all signal generation, entry and exit points calculated mathematically, with zero LLM involvement. This layer doesn't hallucinate. It doesn't guess. It computes. Second, Llama 3.3, running on Groq for sub-second inference, takes those signals and the live exchange state, then generates a plain-English market thesis. Not a summary. A mentor's explanation. The kind of reasoning a seasoned trader would walk you through before placing a position. Execution is handled through the Kraken CLI via the Model Context Protocol (MCP), which keeps credentials environment-isolated and the integration clean. But the part I spent the most time on was safety. Three guardrails are hard-coded and non-negotiable. A 2% risk cap limits capital exposure per trade, institutional standard, enforced at the logic layer. A 3-loss circuit breaker halts all trading after consecutive losses, cutting off the revenge-trading spiral before it starts. A high-fidelity failover protocol preserves session context during API outages or exchange maintenance windows, so a dropped connection doesn't mean a lost position. QuantTrader isn't trying to be the fastest algo on the market. My priority was building something a real trader could actually trust, because they understand what it's doing and why.
12 Apr 2026
ArcFlow - Trustless Financial Kernel
Direct AI wallet access is unsafe: a single hallucination or prompt injection can cause irreversible loss. ArcFlow solves this by acting as a deterministic firewall between Gemini 2.5 and the Arc Network, blocking faulty AI actions from draining wallets. Instead of giving the AI direct signing rights, ArcFlow routes payments through an auditable policy engine and a secure state machine that validates every transaction intent and rejects anything ambiguous or unsafe before it reaches the blockchain. ArcFlow combines Circle’s USDC with Arc’s payment rails to provide safe, programmable money: Gemini 2.5 Flash acts as the brain (a stateless planner that proposes actions via JSON), while ArcFlow is the guard, validating each proposal against strict, hard‑coded rules like max spend limits and whitelists. Only validated transactions are signed and broadcast to the Arc Testnet. This architecture enables autonomous agents—such as refund bots or commerce copilots—while ensuring funds never move outside clearly verifiable policies. Under the hood, I implemented this as a secure state machine using a production‑ready stack: Gemini 2.5 Flash via the Vercel AI SDK for structured planning, a custom TypeScript risk engine for policy enforcement, `ethers.js` for Arc Testnet interaction, and a Node.js backend on Vercel to keep keys secure server‑side. Circle Product Feedback (Required): I used the Arc Testnet, USDC, the Circle Faucet, and `ethers.js` in an environment where USDC is the native gas token, so agents can manage a single asset for both payments and gas. The developer experience was strong overall; the Faucet and ArcScan made on‑chain testing straightforward. I’d suggest surfacing RPC endpoint documentation more prominently and adding a simple “Check Balance” tool on the Faucet page to speed up debugging.
24 Jan 2026
