KIP·CAPITAL ← back to the live board

Under the hood · build-it-yourself guide

How the engine actually works.

Kip Capital is a small, honest machine: it reads the market three ways, asks an AI to decide, checks that decision against hard safety rules, then places a paper trade and shows its work. Here's every part — and how you could build one too.

The one-sentence version

Every few minutes a program gathers fresh market data; when the picture changes it hands it to Claude with a clear question, gets back a buy / sell / hold decision with reasons, runs that decision through a risk gate that can shrink or veto it, and — only if it passes — sends a paper order to the broker and logs everything for this website to display.

Built by a student + an AI — together

This project wasn't made by clicking around a chatbot. It was co-developed: a human and an AI working as partners in a real programmer's terminal. The human brought things a computer can't know on its own — like the way crypto reliably gets wild late at night when few people are trading (the "witching hour" windows), watched first-hand during real trades — and the rules to stay safe. The AI turned those ideas into working code, tested them, and wired up the data. (Kip is the trader; right now his dad is his "lab partner," helping type and check the work — the way a science-fair coach helps run the experiment.)

What the human defined

  • The real edge: the off-peak / overnight volatility windows, from actual trading
  • The goal: long-horizon growth of a small, high-risk bucket
  • The guardrails: paper first, max 25% per coin, cut losers, never average down
  • The seasonal plan: lean in for the Sep–Dec bull window

What the AI built

  • Turned each idea into code: the cycle, sentiment, session & signal engines
  • The risk gate + real stop-losses that fire automatically
  • The nightly reflection engine that learns from past trades
  • This whole live dashboard

What the build actually looks like

Most people picture a chat window. The real work happens in a terminal — a person typing commands to direct the AI, then checking that what it built actually works. Here's a real slice of building Kip Capital:

Real commands, real output. A human decides what to build and checks it; the AI does the heavy lifting and gets corrected when it's wrong. That back-and-forth — not a single magic prompt — is how the engine was made.

The pipeline, end to end

1GatherLive prices + three layers of context
2DecideClaude reads it all, returns a decision + thesis
3CheckRisk gate can cap it, or veto it entirely
4ActPaper order to the broker (no real money)
5ShowEvery move logged & drawn on this page

Step 1 — Three ways of reading the market

Most trading bots look at only one thing — a price line. This one stacks three lenses, from the slowest to the fastest, so the AI sees the season, the time of day, and the moment all at once.

Lens 1 · Macro — the 4-year cycle

Crypto moves in a roughly four-year cycle tied to Bitcoin's "halving." We read a free live index called the CBBI (a 0–100 blend of nine trusted top/bottom signals). Low number = cheap, accumulate. High number = frothy, get careful. This sets how much risk the bot is allowed to take at all.

Lens 2 · Session — the "witching hours"

Crypto trades 24/7, but not evenly. Liquidity thins out overnight (US time), Asian markets hand off, and options expire on set schedules — and prices whip around in those windows. The bot knows the clock and flags when a volatility window is open.

Lens 3 · Signals — what's moving right now

For each coin (BTC, ETH, SOL) the bot computes classic momentum indicators — moving-average crosses, RSI, breakouts, trend regime — and tallies them into a simple buy / sell / hold "vote." This is the fast lens: it catches what's happening today. The three lenses together become the briefing the AI reads.

Step 2 — The AI makes the call

All three lenses, the current portfolio, and a living strategy playbook get written into one prompt. Claude must answer in a strict format — action, symbol, size, confidence, thesis, stop-loss, take-profit — so its decision is machine-readable and human-readable. The thesis is the part you see on the front page: the AI explaining, in plain English, why it did what it did. The playbook grows over time as patterns are learned, so the machine gets a little wiser each cycle.

Step 3 — The safety rails

The AI never gets the last word on risk. A separate risk gate enforces rules it cannot override:

If a decision breaks a rule, the gate shrinks it or throws it out. This is the difference between a science project and a gamble.

Step 4 — It learns from experience

This is the part that makes it more than a script. Every completed trade is saved along with the exact conditions it happened under — the trend, the time-of-day window, the cycle phase, the confidence. Then, once a night, a separate reflection engine reads that whole track record, measures what actually made or lost money (win rate, profit factor, which setups paid off), and asks the AI: "given the evidence, what should we do more of, and what should we stop doing?"

The AI writes those lessons — each backed by a real number — straight into its strategy playbook, which the trader reads before every decision. So the bot literally gets better as it gains experience, the same way a person does. Two guardrails keep it honest: it needs enough trades before drawing a conclusion (so it doesn't overreact to luck), and it can only tune the strategy — never the safety rails. It learns to trade smarter, not to remove its seatbelt. You can watch the lessons appear on the live board.

The toolbox — everything here is free or cheap

AlpacaFree paper-trading brokerage API — real market data, fake money. Where the orders go.
Claude APIThe decision-maker. Called with a strict tool-use format so answers are structured.
CBBIFree live JSON of the Bitcoin cycle index. The "macro" lens.
Python~300 lines glue it together: fetch data, build the prompt, run the gate, place orders.
A cron jobRuns the whole loop every 30 minutes, 24/7. No babysitting.
Static web + JSONThe bot writes a small state file; this page reads it and draws the charts.

Build your own — the recipe

  1. Open a paper account. Sign up for a free brokerage paper API. Practice placing one order from a script. No real money — ever, until you've proven it for months.
  2. Fetch some data. Pull recent price bars for a few assets. Compute one simple signal (like a moving-average cross). Print it.
  3. Add a brain. Write the data into a prompt and ask an AI to answer buy / sell / hold in a fixed format. Parse its answer.
  4. Add rails. Before acting, check the decision against 2–3 hard rules (max position size, minimum confidence). Shrink or skip anything that fails.
  5. Close the loop. Place the paper order. Save what happened to a file.
  6. Put it on a timer. Run it on a schedule. Now it's autonomous.
  7. Show your work. Have it log every decision, and build a page that reads the log. That honesty is the whole point.

Start tiny. Get one step working before adding the next. The magic isn't any single part — it's the loop.

The honest part

Most active traders — human or AI — do worse than someone who just buys a low-cost index fund and waits. That's not an opinion; it's decades of data. So Kip Capital is the small learning bucket, not the plan for getting rich. The real growth engine is time + patience, which is exactly what the "magic of time" chart on the home page is about. Build the bot to understand markets — not to beat them.

← Back to the live trading board

Educational science-fair project by an 11-year-old. Trades a paper account against live market data — no real money is at risk. Nothing here is financial advice. Crypto is extremely volatile; most active strategies underperform simply holding a low-cost index fund. An Outlaw Holdings project.