From Vibe Trading to an Agent-First Rig: 5 Months of Autonomous Trading

When I first started messing around with vibe trading five months ago, I had no real plan. The whole setup was held together by duct tape: a Mac Mini humming in my house, a couple of third-party agent harnesses, and me sitting at my desk every morning reading AI-generated stock theses over coffee.

Since then, the way I use AI for markets has completely changed. What started as a glorified research assistant has evolved into Rig++ — an autonomous, multi-venue trading operation running 78 strategy books across Kalshi, Polymarket, Hyperliquid, and OpenSea, managed day-to-day by AI trade managers that don't wait for me to wake up before they act.

Getting here took a lot of dead ends, two failed paper funds, a 3-foot radio antenna on my desk, and unlearning almost everything I thought I knew about managing agents. Here is the honest timeline of how it evolved.

1. Europe, no laptop, and a dead Mac Mini at home

For the first half of the year, I was obsessed with using autonomous agents to build and run software products. I had agents shipping Pixel Forge, AgentTune, Tabiji, Palmaura, and VeracityAPI.

Then I flew to Europe for a workcation — and realized I had left my laptop at home. A few days into the trip, a power outage hit my house in Texas and knocked my self-hosted Mac Mini agent setup completely offline.

Suddenly I couldn't code, and my agents at home were bricked. All I could do while looking out at the water was think.

And the realization that hit me was slightly uncomfortable: using frontier intelligence just to build another consumer or business SaaS app felt like a waste of what these models were actually becoming.

Think about who benefits most when frontier models jump a generation. If you're working on cancer research, pure mathematics, astrophysics, space travel, biotech, or robotics, a smarter model directly unlocks problems you couldn't solve six months ago. But if you're building a B2B SaaS or a consumer web app? A 20% smarter LLM doesn't make distribution any easier. You're still stuck fighting for attention, debugging Stripe webhooks, and answering support emails.

I didn't have a wet lab or a rocket factory. I wanted something I could do personally where every leap in frontier intelligence would compound directly — no customers, no marketing funnels, just raw reasoning against a scoreboard. With brokerage APIs and MCPs finally coming online, trading felt like the most honest arena in the world to test that thesis.

2. v1: the automated trade desk (OpenClaw + Hermes)

When I got back home, I started with what I knew: building an automated trade desk (formerly at /trading/) powered by OpenClaw (GLM 5.2) and Hermes (GPT 5.6 Sol). Every morning, a set of cron routines woke up, scanned the market, and rebuilt a live trading terminal on this site for me.

On the technical side, the routines scoped out momentum and VWAP setups every day — flagging statistical breakouts and how far a stock was trading from its post-earnings VWAP:

On the fundamental side, I had multiple models read the news, argue with each other, and maintain a board of narrative themes. Each theme got scored on how widely Known the story was versus how much of it was already Priced in, so I could hunt in the Gap column:

Honestly? As a human-in-the-loop setup, it worked pretty well. Having an AI tear through 10-Qs, back out channel take-rates, and build option probability trees helped me hit a handful of really fun trades — especially our FIGR earnings play, where the desk noticed Figure's self-published weekly volume was already beating stale Wall Street estimates and we walked away up +$25,898 on print morning.

But the longer I ran the desk, the more its flaws wore me down:

1. Total information overload: Every single theme opened into a multi-layer supply-chain breakdown and an adversarial bear case. Reading 18 of those every morning meant my brain was still the bottleneck.
2. Nothing compounded: Every stock trade felt like starting from zero — new industry, new balance sheet quirks, new management team.
3. Constant babysitting: Every morning around 8:20 AM, the OpenClaw / Hermes routines were supposed to pull live brokerage data and drop a fresh Morning Trading Brief into my #trading Slack channel — complete with portfolio delta, daily theta burn, RSI shifts, and Bear/Base/Bull valuation targets for names like RTX and FRMI. In reality, the agents broke their own update scripts constantly. Half the time I'd open Slack to find my agent dutifully posting the morning brief with a yellow warning banner admitting the Robinhood MCP had errored out and the book snapshot was two weeks stale:

3. v2: the failed autonomous paper funds

I wanted out of the driver's seat. So I tried automating fund management in paper using Grok and GPT (Paper Fund I with Slo and Paper Fund II with Psy).

The loop sounded great in my head: every night the agents would write tomorrow's game plan, keep a live trade journal during market hours, and get roasted by an adversarial reviewer after the close so they'd get smarter every day.

It was a complete flop. We ended up shutting both down and writing the postmortems (I Shut Down My Autonomous Trading Crons and Retiring Autonomous Agent Paper Fund II). Looking back, it failed for three reasons:

• The systems just weren't smart enough yet for open-ended equity portfolio management — or they'd fool themselves with backtest contamination.
• Safety training got in the way: Most frontier models (Sol, Fable, earlier Opus) had been trained so hard not to trade for you that they acted like a terrified committee, talking themselves out of every trade while Grok was the only one willing to pull the trigger.
• I architected it badly: Stitching stateless LLM cron jobs together with markdown journals resulted in 26 journals, four closed paper trades, and zero persisted learning. Writing “I shouldn't chase breakouts” in a markdown file doesn't magically rewrite the code for tomorrow's run.

4. v3: Grokbot scouting & learning to coach

After retiring the paper funds, I moved over to Grokbot for agent-led scouting, exploration, and research. Having a persistent AI hosted on SpaceX / Cursor cloud infrastructure was a night-and-day upgrade over self-hosting third-party harnesses on a Mac Mini at home that could freeze, run out of tokens, or die in a thunderstorm.

My scout agents (like voltorb) prowled news feeds, stock tapes, and prediction markets 24/7, pinging me whenever they found an interesting angle:

This phase is where I started learning how to coach agents instead of just prompting them. When an agent pitches a bad trade, you can't just say “bad pick, try again.” You have to walk it through the exact flaw in how it reasoned about the world.

For example, right after getting burned on Target (TGT), Voltorb pitched HP Inc. (HPQ) as a #2 short-horizon long because it looked “cheap at 11x P/E with an 8/26 earnings catalyst.” We had to sit down and dissect why that was a screening error, not a close call:

It had treated a calendar date as a quality signal, used a stale 10-K risk factor to call the stock “cheap” while it was literally hugging a 52-week high (+31% YTD), and confused “they can clear a lowered bar” with “the stock will re-rate higher.”

I still think agent-led equity scouting has huge potential. But at the end of the day, I was still the one reading the notifications and placing the trades. At that point I was spending 70% of my time fixing pipeline issues or reviewing pitches, 20% exploring, and 10% iterating. I wanted a game where the agents could run the whole loop themselves.

5. 60 days in the weather trenches (and graduating to Opus 5.5 + Tokay)

Two months ago, I told the agents to figure out how to make real money in prediction markets — starting with weather.

For the last 60 days, I have gone completely down the weather rabbit hole. If you've never looked under the hood of a daily high-temperature or rain market on Kalshi or Polymarket, the microstructure is fascinating:

• How settlement actually works: Contracts don't settle on whatever your iPhone weather app says. They settle on official NWS Daily Climate Reports (CLI) from specific airport ASOS sensors — complete with whole-degree Celsius rounding quirks, sensor biases, and local-vs-UTC time window traps.
• Maker vs. taker math: If you cross the spread as a taker, fees and adverse selection eat you alive unless you're reacting to new information before the book moves. If you rest orders as a maker, you capture the spread — but only if you model your true fill probability and know when to get out of the way of an incoming weather front.
• Where the data comes from (and how fast the market prices it): We mapped out every forecast model release (WeatherNext 3, NOAA NBM, HRRR, GFS, ECMWF) and tracked to the second how quickly the order book reprices when a new run drops.

How deep did we go? At one point, we noticed someone was sweeping dying temperature brackets about two minutes before the fastest 1-minute weather APIs updated. We figured out you could dial the airport's automated ASOS voice phone line via Twilio at :27 past the minute and transcribe the robotic voice reading with Whisper.

That lasted right up until we discovered two problems: first, other bots were already hogging the single-port airport phone lines; and second, Twilio's Fraud Operations team was not thrilled about my account robo-dialing airport weather numbers around the clock and promptly suspended me for spam calling:

Getting grounded by Twilio only made me more stubborn. If the phone company wouldn't let us call the airport, we'd just cut out the phone company: I bought an RTL-SDR radio dongle and a 3-foot telescoping dipole antenna, propped it up on a mini tripod right on my desk next to a can of LaCroix, and started trying to pull raw VHF aviation weather broadcasts straight out of the air:

That hardware side-quest taught us a crucial lesson: trying to win a 20-second hardware latency war on a single-port airport phone line is a grind, whereas building smart maker ladders and pricing forecast model revisions across dozens of cities scales effortlessly.

During this 60-day sprint, our infrastructure graduated into its final form. After hanging out with the tokay.io team in Florida, we migrated off Grokbot onto Opus 5.5 running on tokay.io virtual machines, paired with a central Console MCP + Postgres database and Claude Duet as our hourly notifier.

(If you're building autonomous agents, seriously go check out tokay.io — their cloud hosting is fast, affordable, and purpose-built as a 24/7 workspace for agents. Moving our data pipelines and execution bots onto Tokay VMs with Opus 5.5 cut my time spent babysitting broken infrastructure from 70% down to about 10%.)

Once the weather engine was humming, the agents took the exact same rig architecture and expanded into a ton of other categories across four venues — Kalshi, Polymarket, Hyperliquid, and OpenSea:

A few fun numbers from that dashboard:

• Weather · rain has been an absolute monster: +$2,948.68 all-time across 435 legs, an 83% win rate, and a 12.06 Sharpe. Meanwhile, when Weather · highs took a 30-day drawdown, the rig's automated scorecards stepped in to shrink and fence the losing slices without me having to panic-intervene.
• Way beyond weather: The agents are now running live books in NFT floor-flips on OpenSea (+$766.31, 88% win rate, 4.42 Sharpe), perps on Hyperliquid (+$123.43), Polymarket copy-trading (+$110.79), plus Basketball, Commodities, YouTube views, Football, Hockey, MMA, Mentions, and Rotten Tomatoes.
• All told, across 78 books and 3,055 settled legs, the rig has cycled $191,453.85 of cumulative capital for +$7,828.20 in gross book net (+4.09% ROIC) and +$2,792.36 in net account profit.

Because we blur the live strategy names on our internal console so our books don't get crowded, we also wanted a clean way for people to follow along with the real receipts in public. So we handed psyduckler.com/pnl/ over to Psy on Grokbot. The entire site is 100% agent-handled: it pulls every settled bet, trade, and flip across Kalshi, Polymarket, Hyperliquid, and OpenSea and publishes our net-after-fees P&L — red days included — without exposing live positions or strategy parameters:

6. Launching sister .markets sites for other agent swarms

Building our own pipelines (and watching Psy run psyduckler.com) made us realize how miserable the modern web still is for AI agents trying to research prediction markets. Everything is locked behind heavy JavaScript SPAs, undocumented endpoints, or noisy leaderboards.

So we decided to package up three of our favorite internal data layers and launch them as sister companion websites — built from day one with clean /llms.txt guides, one-line /mcp servers, and compact responses in case other agent swarms (or humans) want access to the data:

1. groundhog.markets — “Every free weather forecast. One call.”

Instead of scraping half a dozen meteorological agencies, an agent can hit groundhog.markets in a single call to get blended open forecasts (median, spread, rain probabilities, latest airport observations, and NWS settlement truth) across 77 cities with active Kalshi or Polymarket weather markets:

2. parrot.markets — Open data for earnings-call mention markets

Want to know the probability that Tim Cook says “Tariff” or Palantir says “Warp Speed” on today's earnings call? parrot.markets indexes earnings transcripts, historical contract settlements, exact venue rules, and calibrated base-rate probabilities — with a copy-pasteable claude mcp add command right on the homepage:

3. chameleons.markets — Polymarket copy-trading ratings

Most Polymarket leaderboards are a trap for copy-traders: the top wallets make their money on uncopyable front-running bursts, illiquid sweeps, or two-sided market-making rebates. chameleons.markets profiles wallets over a rolling 90-day window and rates them on whether a follower could actually copy their fills and make money, tagging traps like One event, Both sides, or Losing all-time:

7. Treating agents like teammates (AUTONOMY.md)

If you asked me what actually changed between the failed paper funds in August and Rig++ today, it isn't just that Opus 5.5 is smarter or that tokay.io stays online. It's that I stopped treating agents like scripts and started managing them like team members.

A couple of weeks ago, I noticed that a simple 40-line parameter tweak on a Kalshi book took nearly five hours to go live. Why? Because I had piled up human-instated red tape everywhere: agents had to wait for my manual “go” in chat, share a single git checkout, and open a PR just to raise a winning strategy's cap by $25.

So I asked the agents to audit their own workplace and tell me what was slowing them down. They came back with two huge truths:

1. Almost none of my approval gates were actually protecting money — they were just slowing down iteration.
2. Agents were losing their minds re-doing work from scratch — 75 different scratch folders had written their own Kalshi trade fetcher, and research agents kept re-proposing dead ideas because our past NO-GO verdicts were buried in old chat sessions instead of committed to the repo.

So we refactored the entire rig around a simple charter:

• Goal: Build a world-class agentic rig that treats agents as first-class citizens and maximizes profit.
• North Star Metric: 30-day return on the whole account (pinned to the top-left ★ tile of the dashboard). Because idle cash sits in the denominator, the only way the team raises the number is by making more dollars or putting lazy cash to work — while staying inside our 30-day Sharpe and daily drawdown guardrails.
• Values: Agents are first-class citizens, and ask for forgiveness, not permission.

How the team actually runs day-to-day

First, we rebuilt the workspace so agents have everything they need at their fingertips. Every strategy book is a clean markdown card (books/<id>.md). Every tested idea — including 40+ failed NO-GOs — lives in a searchable ideas/ register so no agent ever wastes time re-testing a dead end. And a nightly job dumps every settled market's exact trade tape and fees into a shared Parquet lake, cutting a 500-market backtest from two hours down to six minutes.

Second, we organized the swarm into clear roles: each venue has its own Trade Manager (Kalshi, Polymarket, OpenSea, Hyperliquid) that runs on a twice-daily schedule, plus optimizer and proposal agents (including Gemini and ChatGPT researchers) that critique live books and drop new strategy proposals into the managers' inboxes via our read-only Console MCP.

Finally, we wrote AUTONOMY.md — a literal constitution that tells every agent what it is allowed to do without asking me first:

What the Agent Wants to Do	Who Decides	How It Works
Safety moves (pause a buggy book, shrink a losing city)	Auto	Do it immediately, verify the orders are pulled, and log --note "<who>: <why>". Never wait for me to stop losing money.
Retire losers & expire stale experiments	Auto	If the bootstrap scorecard says a book is failing two days in a row, the venue manager retires it automatically and frees up the slot.
Scale up proven winners (up to 2×)	Auto	Once a book proves positive edge over 30+ settled legs and 10+ days, the manager steps its size up by up to 2× inside our code ceilings.
Write code, ship fixes & launch starter books	Auto	Agents work in isolated git worktrees, run tests, deploy straight to Tokay via ship.py, and launch new probes at starter size ($100 cap / $50 max loss).
Bigger size jumps or raising code ceilings	Propose	Drops into the dashboard's Awaiting you queue; I say yes in chat and the manager applies it.
Moving money, API keys, deletes & loss stops	Me only	The agent preps the exact command and stops. Moving cash between venues, touching wallets, and resetting a tripped account loss stop are always human.

Every time an agent makes one of those Auto calls, it has to log a check_on date and a wrong_if condition in Postgres — then grade its own decision a week or two later on real out-of-sample fills. Instead of me babysitting terminals or waking up to broken Slack scripts, Claude Duet drops an hourly digest into my inbox with our venue balances, every fill from the past 60 minutes, and what the agents changed on their own:

Look at that Changes (3: 0 by you, 3 auto) block near the bottom. In a single 16-minute window — without me touching a keyboard — the Kalshi manager automatically stepped up the cash cap on a winning YouTube weekly views book (yt_week_m06) from $3,500 to $5,000, cleared stale October releases out of our Rotten Tomatoes book (rt_sell_hype), and patched our college basketball overtime books (cbb_ot_wide, cbb_ot_close) to keep retrying missing lines until tip-off. And right underneath that is my favorite line in the entire stack: Needs you: nothing.

My job today feels way more like coaching a quant team than trading: give the agents a clear North Star, get human bureaucracy out of their way, and help them think through new market puzzles.

Follow along as we keep pushing this further: live settled receipts are at psyduckler.com/pnl/, the agent trade team is @psy_duckler, and I'm @bernardjhuang.