Let's connect
All work

01 · Work · Meridian Capital

Meridian Capital.

A public experiment: an autonomous trading system where six AI agents research a stock, debate it, and place the trade. It runs on free LLMs, either Groq's free tier or a local Ollama model, so it costs nothing to run.

Everything happens in Alpaca paper trading. No real money moves. It defaults to paper and only trades live if you deliberately switch it to live mode and give it a live key. I built it to learn how multi-agent systems reason and disagree, and the whole thing is open on GitHub.

Role
Builder
Team
Solo
Stack
  • Next.js
  • TypeScript
  • SQLite
  • Server-Sent Events
  • Alpaca API
  • Groq, Ollama
  • Vitest
The Meridian Capital dashboard: a six-agent analysis pipeline (research, quant, macro, risk, portfolio, trader), a pixel-art live trading floor, agent status cards and a paper-mode portfolio, with a STOP kill switch.
FIG. 02 · The live dashboard: the six-agent pipeline over a pixel-art trading floor
Meridian Capital, lower dashboard: status cards for five of the agents with their roles, and the safety controls: a kill switch, a 5% daily loss limit, a 15% cap per position and an 8% stop loss per trade.
FIG. 03 · Agent status, and the safety controls: a kill switch and hard loss limits

Esc or click to close

6
AI agents
31
stocks on the watchlist
68
automated tests

02 · Story

Why it exists.

  1. Why I built it

    To watch AI agents disagree.

    I wanted to learn how multi-agent systems reason, argue and veto each other, on something with a clear score: a portfolio against the S&P 500.

Who stays in controlPaper money only by default, and a kill switch halts all trading at once.

03 · How it works

How it works.

  • Six agents, one pipeline

    One agent researches news and fundamentals, one runs the technicals, one reads the macro cycle, one manages risk, one makes the final call, and one places the order. Each stock flows through all six every cycle.

  • They can veto each other

    If the researcher's conviction is too low the pipeline short-circuits and skips the stock to save API calls. The risk manager can hard-veto a trade, and the portfolio manager cannot override it.

  • It learns from closed trades

    When a position sells, the actual profit or loss is written back as a plain-English lesson into a SQLite memory table. Next time the agents look at that stock, their prompt includes the last few lessons.

  • Watch it live

    A Next.js dashboard streams every decision over Server-Sent Events: the agent debate, the portfolio, benchmarks against the S&P 500, and a manual kill switch that halts all trading instantly.

04 · Features

What it does.

  • Hard position limits

    No single position can pass 15% of the portfolio, and it can never spend more cash than it has.

  • Stop-loss and a daily limit

    An 8% stop-loss is checked every cycle, and a 5% loss in one day trips the kill switch on its own.

  • A kill switch that sticks

    The manual kill switch survives a code reload, so a restart cannot quietly switch trading back on.

  • No churn

    The trader holds every position for at least 24 hours.

  • A hedge for bad markets

    In a bear cycle the portfolio manager can hedge with inverse funds instead of only selling.

  • Agents with a scorecard

    Each agent's accuracy is tracked on the dashboard, next to the S&P 500, NASDAQ, Nifty 50 and Sensex.

05 · Scenarios

Where it's used.

  1. Learning AI agents

    Watching them disagree.

    Each decision shows every agent's conviction, the risk manager's veto, and the final call side by side.

  2. Running it for free

    No bill at all.

    Groq's free tier or a local Ollama model, on a free host.

  3. Testing risk rules

    Before any real money.

    The same limits apply in paper and live mode, so every rule is proven on paper first.

Let's connect.

I am not looking for work. I am looking for good people to know.

Index

  1. 1Home
  2. 2Work
  3. 3Security
  4. 4About