What this is

An autonomous options trading agent for NIFTY + BANKNIFTY. Instead of coded rules like "if RSI > 70 sell" or "EMA crossover → buy," the agent sends market data to Claude (Anthropic's LLM) every 15 minutes and lets it decide: trade or wait, CE or PE, which strike, when to exit.

The idea: an LLM can weigh 15+ inputs simultaneously and make contextual judgments that fixed rules can't. "Regime is bullish and 6/7 signals agree, but VIX just spiked 3 points in 10 minutes — wait." No indicator combo can reason like that.

Whether this actually works better than a well-tuned rule-based system is what I'm testing. Week 1 results say: maybe, but the exits need serious work.

Architecture (for the technical crowd)

Market Data (Upstox WebSocket + REST API)
    │
    ▼
┌─────────────────────────────┐
│  Data Layer                 │
│  Spot, Option Chain, Greeks,│
│  VIX, PCR, FII/DII, OI     │
│  15min/5min candles         │
└───────────┬─────────────────┘
            ▼
┌─────────────────────────────┐
│  Agent (Maker)              │
│  Claude Haiku — proposes    │
│  trade with reasoning       │
└───────────┬─────────────────┘
            ▼
┌─────────────────────────────┐
│  Checker (Validator)        │
│  Claude Sonnet — reviews    │
│  and approves/rejects       │
└───────────┬─────────────────┘
            ▼
┌─────────────────────────────┐
│  Paper Broker               │
│  Real bid/ask fills         │
│  Real costs (Upstox API)    │
│  Real margin checks         │
│  Trailing SL on live ticks  │
└─────────────────────────────┘

Dual-agent validation: A cheaper model (Haiku) proposes trades. A smarter model (Sonnet) reviews every proposal before execution. Think of it as trader + risk manager. ~Rs 100-150/day API cost for both combined.

Risk monitor: Background thread checks every few seconds — trailing stop-loss updates on real WebSocket ticks, daily loss halt (4% of capital), smart EOD exit (closes expiring/losing positions at 3:15 PM, holds profitable ones overnight).

Why not just code the rules?

I saw a post here recently: "RS + VWAP on 5min, profit factor < 1." And a comment: "Only indicator based algos will not be consistent in long run." That matched my experience.

The problem with indicator rules isn't the indicators — it's that markets change context. A RSI 70 during a breakout is a continuation signal. A RSI 70 at resistance is exhaustion. A coded rule treats them identically. An LLM can read the surrounding context and distinguish them.

The counter-argument (which I take seriously): maybe Claude is just doing the same pattern matching with extra steps and extra cost. Week 2 will test this specifically — I'm auditing whether Claude actually reasons differently with contextual data, or just mechanically follows regime + RSI like a fancy indicator algo.

What makes the paper trading realistic

This is the part I'm most confident about. Most paper results are fantasy because they fill at LTP with zero slippage. Ours doesn't:

Factor	Our Approach
Fill price	BUY at ask, SELL at bid — real WebSocket depth data, ~1 tick/sec
Slippage	Depth-based + VIX/time jitter. Extra penalty if spread > ₹5
Costs	Real Upstox brokerage API (not estimated). STT, exchange txn, GST, stamp duty — all from broker
Margins	Real Upstox margin API. Can't enter trades the account can't hold
Position monitoring	WebSocket FO ticks for open positions. Trail SL updates on real price movement

Week 1 results (Jul 1-3) — honest numbers

Capital: ₹5,00,000. NIFTY + BANKNIFTY options, BUY-only directional, 1-2 lots.

Day	Trades	What happened	Realized P&L
Jul 1	3	Entries correct, exits broken. FO ticks wired mid-day.	₹0 (held overnight)
Jul 2	3	All entries caught direction right. Trail SL too loose — gave back ₹11K unrealized on one trade.	+₹1,746
Jul 3	3	New trail SL deployed (8%→3%→2%). Agent skipped all afternoon cycles.	Testing, not trading

Net Week 1: +₹1,746 realized. Not meaningful. The real finding is below.

What actually went wrong (the useful part)

1. Trail SL was the #1 problem, not entry signals. On Jul 2, a BANKNIFTY position hit +₹6,295 unrealized within 10 minutes of entry. By EOD it was -₹5,989. That's an ₹11K swing because the trailing stop was set at 35% — way too loose for options that can move 10% in minutes. Fixed to 8%→3%→2% progressive tightening. The entry was right. The exit let the profit evaporate.

2. Claude enters on Cycle 1 every single day. 9:30 AM, first cycle, Claude sees "regime BULLISH, 6/7 signals agree" and enters immediately. Never waits for a pullback, never says "let me observe for 30 minutes." In 5 out of 6 trading days, Cycle 1 = instant entry. This looks like pattern matching, not reasoning.

3. A 0.2% price-move gate killed the entire afternoon. I had a gate: "if market moved < 0.2% since last cycle, skip." On Jul 3, after all positions exited by 10:55 AM, the market went flat. The gate skipped every cycle from 11:17 to market close. With zero positions open, the agent should have been scanning for new entries, not sleeping. A 3-line fix, but it cost an entire afternoon.

4. Cost API was returning ₹0. Upstox brokerage API returns {"charges": {"total": 49.32}} but my code read data.total instead of data.charges.total. Every trade showed Costs = ₹0.00. The kind of bug that looks fine in logs until you check the numbers.

Current input audit

Inspired by that excellent "₹25L → ₹2.7Cr backtest autopsy" post here — I tagged every system input:

Input	Tag
Slippage (depth-based)	MEASURED — real bid/ask
Trading costs	MEASURED — real Upstox API
Margins	MEASURED — real Upstox API
Trail SL percentages	ASSUMED — 3 days data
Regime detection	ESTIMATED — EMA/SuperTrend, not validated
Cooldown (30 min)	ASSUMED — picked a number
Daily loss limit (4%)	ASSUMED — reasonable but arbitrary
Taxes	NOT MODELED

4 measured, 2 estimated, 4 assumed. The assumed column is the real risk.

What's next

• This weekend (Jul 4-5): Adding momentum data (VWAP, change from open, candle trend), IV rank, put/call IV skew — not as rules, but as context for Claude to reason about
• Week 2 (Jul 7-11): Pure observation. Does Claude actually use the new data to make better decisions, or does it keep entering on Cycle 1? If it ignores the data, the features are noise — cut them
• Aug 28: Go/no-go decision for live trading with real (small) capital

Questions for this sub

1. For those who've gone from paper → live: what was the biggest gap that paper trading didn't reveal? (Even with realistic fills, I'm sure I'm missing something)
2. Has anyone used LLMs for actual trade decisions (not just analysis/summaries)? What was your experience with consistency — does the LLM make the same decision given the same inputs?
3. The dual-agent (proposer + reviewer) setup costs ~₹100-150/day in API calls. Is that worth it over a single model, or is the "checker" just rubber-stamping?

905 unit tests. No paid tools — everything runs on Upstox free API + Anthropic API (₹100-150/day). Code is private but happy to share architecture details in comments.

I've been building an AI-powered options trading agent for NSE (Nifty & BankNifty) using Claude AI as the brain. After months of coding and 750+ unit tests, I finally started paper trading this week. Here are the first 2 days:

Day 1 (Jun 24) — The Spreads Day

Market opened mildly bullish. The agent detected 5/7 bullish signals on the MTF scorecard and decided to go with Bull Call Spreads — the "safer" play for mild trends. It placed 4 spreads throughout the day.

• All 4 were profitable, but here's the catch — costs ate 38% of the gross profit. Each spread has 4 orders (buy + sell entry, buy + sell exit), so transaction costs double compared to a simple directional trade.
• Gross PNL: +₹1,494, Net after costs: +₹925
• Found a critical bug: the trailing SL was triggering on individual spread legs separately instead of tracking the net P&L of the whole spread. One leg would get stopped out while the other was still profitable, leaving a naked position. Fixed it the same evening — now spreads trail on combined net P&L.

Day 2 (Jun 25) — The Directional Day

Strong bullish signals this time — 6/7 MTF alignment on both NIFTY and BANKNIFTY. The agent chose BUY CE (naked call buys) instead of spreads because the signals were strong enough. Much better day:

• Trade 1: NIFTY CE — entered around 10:30 AM, hit Target 1 (+50%), trail kicked in. Trail SL triggered around 12:30 PM. Net: +₹945
• Trade 2: BANKNIFTY CE — entered around 11:15 AM after NIFTY's success confirmed the trend. Same pattern — hit T1, trailed, stopped out. Net: +₹583

Both trades were profitable, but the post-market analysis told a different story. The MFE (Maximum Favorable Excursion) tracking showed we left a lot on the table — NIFTY's option price peaked at ₹129 but the trailing SL closed us at ₹108 (22% capture). BANKNIFTY peaked at ₹330 but closed at ₹284 (only 14% capture). The problem? After hitting Target 1, the trail was still using a loose 30% distance from the peak. By the time it triggered, the price had already given back a big chunk of gains. This led us to build a graduated trailing SL — the trail now tightens after each target hit: 30% → 20% → 15% for buys. Running the same Day 2 data through the new graduated trail would have added an extra +₹2,887 in captured profit.

• The agent then tried to re-enter in the afternoon but the checker model rejected both proposals citing VIX concerns (turned out to be a bug — it was confusing VIX percentile rank with the actual VIX level. Fixed that too)
• Costs were only 7.9% of gross — 2 orders instead of 4 makes a huge difference at small capital
• Had 21 Upstox API timeouts in a 4-minute window around 1:35 PM — thankfully no positions were open. The risk monitor kept running independently and would have protected us if we had positions.
• The agent skipped 16 out of 23 cycles because signals weren't strong enough. No FOMO, no revenge trading, just pure discipline.

Combined: +₹2,453 in 2 days on ₹100K capital (+2.45%), 6 trades, 100% win rate

How the Agent Works

It runs a dual-agent maker-checker system:

• Maker (Claude Haiku — cheap model): Scans the market every 15 minutes. Fetches spot prices, VIX, FII/DII flows, PCR, option chain, and runs multi-timeframe technical analysis across daily + 15min + 5min candles. A 7-signal MTF scorecard (RSI, MACD, EMA trend, SuperTrend across timeframes) decides if there's a tradeable signal. Needs 5+/7 signals aligned to propose a trade. If signals are weak or mixed, it skips the cycle — no forcing trades.
• Checker (Claude Sonnet — smarter model): Only fires when Maker proposes a trade. Validates signal strength, checks if there's enough capital/margin, verifies the expected profit exceeds 1.5x the round-trip transaction costs (friction hurdle), checks for conflicts with existing positions, and verifies NIFTY-BANKNIFTY cross-correlation. Can APPROVE, REJECT, or MODIFY the proposal.

The agent decides between naked buys and spreads based on signal strength, VIX level, and available capital. Strong signals (6+/7) favor directional buys, mild signals (5/7) with low VIX favor spreads.

API cost to run this? $0.15 on Day 1, $0.29 on Day 2. Roughly ₹13-25/day. Anthropic's prompt caching makes it ridiculously cheap — the Haiku maker calls cost almost nothing, and the Sonnet checker only fires on actual trade proposals (2-3 times a day).

Safety Features (What Protects the Capital)

This is where most of the engineering effort went. The AI makes decisions, but all risk management is code-enforced — Claude can't override these:

1. Independent Risk Monitor — A separate thread runs every 30 seconds, completely independent of Claude. Even if the API goes down or Claude hallucinates, the risk monitor keeps protecting your positions.
2. Cascading Trailing SL — 50% initial SL, 50% target ladder. After each target hit, the trail tightens: 30% → 20% → 15% for buys, 40% → 30% → 25% for sells. Locks in more profit as the trade goes your way.
3. Daily Loss Halt — If realized + unrealized losses hit 6% of capital (₹6,000 on ₹100K), all trading stops for the day. No exceptions.
4. Expiry Protection — Auto-closes all DTE-0 positions at 3:15 PM. After 1:30 PM on expiry day, applies a tight 10% gamma SL on expiring positions. Positions on future expiries are held safely overnight.
5. Capital Tier Limits — Max 2 lots and 4 positions for the Medium tier (₹75K-₹150K). The broker validates every order against margin requirements using Upstox's actual SPAN margin API.
6. Friction Hurdle — Every trade must have expected profit > 1.5x round-trip costs. This killed the "small scalp" problem where you win ₹200 but pay ₹150 in costs.
7. Dual-Agent Validation — No trade goes through without the checker approving it. Even if the maker hallucinates a perfect setup, the checker catches nonsense.
8. Data Staleness Detection — If market data stops updating (API outage), the risk monitor pauses price-based SL/target checks but keeps time-based protections (EOD exit, gamma mode) running. No stale-price stop-outs.
9. Per-Symbol Cooldown — After a trailing SL exit, the agent waits 1-2 cycles before re-entering that specific symbol. Prevents revenge re-entry right after getting stopped out. But other symbols are unaffected — NIFTY's cooldown doesn't block BANKNIFTY.
10. Naked SELL Blocked — The agent can only sell options as part of a defined-risk spread (with a corresponding buy leg). No naked selling = no unlimited risk.

Making Paper Trading More Realistic

Paper trading can give you false confidence if you're not careful. Here's what we've already built and what's coming to keep it honest:

Already built:

• Realistic slippage model — not just a flat percentage. It factors in moneyness (OTM options have wider spreads), VIX level (high vol = worse fills), time of day (opening and closing hours are worse), symbol liquidity (FINNIFTY worse than NIFTY), and whether it's an entry or exit (exits get slightly worse fills due to urgency). Random jitter on top to simulate real-world variance.
• Full transaction cost deduction — every trade deducts STT (0.15% sell-side), brokerage (₹20/order), exchange transaction charges, SEBI fees, stamp duty, and GST. Net P&L is always after costs, never gross.
• Real SPAN margin checks — uses Upstox's actual margin API to validate whether you can afford a trade. Paper broker doesn't let you place orders your real account couldn't handle.
• MFE/MAE tracking — records the maximum favorable and adverse excursion for every trade with timestamps. Tells you exactly how much profit you left on the table and how close you came to getting stopped out.
• 8 CSV log files — every trade, every cycle, every API call logged. Post-market analysis catches things real-time monitoring misses.

Coming next:

• Persisting closed trades across restarts — right now if the agent restarts mid-day, it forgets earlier losses. The daily loss halt won't know about pre-restart trades. Must fix before live.
• IV rank and skew analysis — the agent currently trades on price action alone. Adding implied volatility rank (is IV high or low relative to its own history?) and put-call skew will help it avoid buying overpriced options.
• Trade memory — teaching the agent to learn from its own trades within the session. "Last time you bought NIFTY CE in this setup, it got stopped out" — pattern recognition across the trading day.
• WebSocket real-time data — currently polling every 5 seconds via REST API. WebSocket gives tick-by-tick updates, which means the risk monitor catches SL hits faster. For paper trading, this also lets us upgrade the slippage model — instead of estimating fills from a formula (moneyness + VIX + time factors), we can simulate fills against the actual bid-ask spread from the live order book. When we go live, the slippage model goes away entirely — the broker gives us real fill prices, and we just measure the actual slippage (signal price vs fill price) in our price comparison CSV.
• Risk monitor upgrade — with WebSocket feeding real-time ticks, the risk monitor will check SL/target on every price update instead of polling every 30 seconds. A 30-second gap means a fast-moving option could blow past your stop loss before the monitor even sees it. Tick-by-tick checks close that gap.

The goal is simple — if it's consistently profitable in paper with realistic slippage, costs, and margin constraints over 2 months, then it's ready for real money. If it can't make money in paper, it definitely won't make money live.

Biggest Lessons So Far:

1. Spreads eat your profits in transaction costs at small capital (₹100K). Naked directional is better until capital grows
2. Bug hunting is 80% of the work — found and fixed 20+ bugs across 2 days of paper trading
3. The trailing SL gives back gains (MFE capture was only 14-22%) but it protects against reversals
4. AI doesn't get emotional — it skipped 70% of cycles because signals weren't strong enough. That discipline is worth more than any indicator

Still in paper trading. Planning to run for 2 months before going live with real money. Would love to hear from others building algo trading systems for Indian markets!

Tech stack: Python, Claude API (Haiku + Sonnet), Upstox API (free), 753 unit tests, custom risk monitor

I'm building an options trading agent and planning to move from Upstox (paper) to Kite Connect (live) in a few months.

I've gone through the Kite Connect v3 REST API docs thoroughly, but have some gaps. Looking for answers from people actually using the paid API.

Data endpoints — unclear from docs:

1. Option chain — Is there a dedicated endpoint that returns all strikes with LTP, OI, bid/ask for an underlying? Or do you build it manually from instruments() CSV + batch quote()?
2. Greeks — IV, delta, gamma, theta, vega per contract. Kite web app shows these but I don't see them in the API response fields. Are they in the paid plan?
3. Does the ₹500/month plan unlock any additional endpoints not in the public docs?

Order API — need clarity:

1. Basket/multi-leg orders — Docs show POST /margins/basket for margin calculation, but the basket order endpoint looks consumer-facing (browser confirm). Is there a programmatic basket order API for placing 2-leg spreads atomically?
2. Spread order placement — If no programmatic basket, what's the best practice? Place BUY leg first then SELL? Or SELL first? How do you handle the gap where one leg is filled but the other isn't (naked exposure)?
3. SL-M reliability — How reliable is SL-M with market_protection in fast-moving markets? Any slippage horror stories on BANKNIFTY?
4. Order rate limits — Docs mention 10 orders/second. Is that per API key or per user? Any throttling issues during market open (9:15-9:30)?
5. GTT OCO — Anyone using GTT two-leg (target + SL) for options? Does it work well or are there edge cases?

What I know works (confirmed from docs):

• WebSocket (3000 instruments, OI, 5-level depth)
• POST /margins/basket for spread margin with benefit
• POST /charges/orders for virtual contract note
• Historical candles with OI
• Auto-slice for freeze quantity
• SL-M with market protection parameter

Currently using Upstox free API which gives option chain + Greeks + OI in one call. Want to understand what I need to build myself vs what Kite provides, before committing to the ₹500/month plan.

Any Kite Connect users running option spread strategies — would love to hear your setup. Thanks!

I've been building an automated options trading agent for NIFTY/BANKNIFTY that uses an LLM (Claude) as its brain. Unlike traditional rule-based algos, the AI reads market data every ~15 minutes and makes judgment calls — when to enter, what strike to pick, when to exit — similar to how a discretionary trader would, but without the emotions.

The problem I'm trying to solve:

Rule-based algos are rigid. They work until market regime changes, then they don't. A strategy that prints money in trending markets gets chopped up in sideways ones. You end up maintaining 10 different parameter sets or manually switching strategies. I wanted something that can read the market context — is it trending or ranging, is VIX elevated, are FIIs buying or selling, is it expiry week — and adapt its approach the way an experienced trader would.

How it works:

The agent has access to 11 tools — it can pull spot price, full option chain with Greeks, technicals (RSI, MACD, Bollinger Bands, SuperTrend, EMA, ATR, support/resistance levels, plus a 7-signal multi-timeframe scorecard), VIX, PCR, FII/DII flows, Max Pain, OI data, and its own portfolio. Every 15-minute cycle, it analyzes all of this and decides: trade, hold, or sit out. It picks its own strikes, expiry, and position size.

The AI doesn't just get raw numbers — it gets context. The system tells it what market regime we're in (trending/ranging/volatile), what session phase it is (opening, mid-morning, afternoon, closing), how many DTE the nearest expiry has, and what its current P&L looks like. It makes decisions with the full picture, not just isolated signals.

Key design choices:

• Dual-agent system — One agent (the Maker) proposes the trade with full reasoning. A completely separate agent (the Checker) reviews the proposal and can reject it. The Checker sees the same market data but independently evaluates whether the trade makes sense. Like having a trader and a risk manager who don't always agree. In testing, this catches a lot of impulsive or poorly-reasoned trades before they happen.
• Independent risk monitor — Runs on its own 30-second thread, completely independent of the AI. Even if the LLM hallucinates or hangs, this keeps running. It enforces:
  • Trailing stop loss: 50% initial SL → target ladder at 50% profit → 30% continuous trail after that
  • Smart EOD: DTE ≤ 1 → force close at 3:15 PM, DTE ≥ 2 → can hold overnight
  • Expiry day gamma mode: after 1:30 PM → 10% hard SL (gamma risk is real)
  • Daily loss halt: if realized loss exceeds limit for the capital tier, stop all trading until next day
  • Max 4 concurrent positions, per-trade capital capped at percentage of total capital
• Option buying and spreads only — Starting with ₹1L capital, so naked selling is out. Directional calls/puts, bull/bear spreads, occasional straddles/strangles. The AI chooses strategy type based on market regime and VIX level.
• Live safety plan — Kite Connect for everything. SL-M placed on exchange immediately after every fill — if the agent crashes, internet drops, or my laptop dies, positions are still protected at the exchange level. GTT backup orders as a second safety net. Position reconciliation on every startup (compare agent state vs broker positions, flag mismatches).

What the AI actually sees each cycle:

Each 15-minute cycle, Claude gets a trimmed summary of:

• Spot price + change %
• Full option chain (strikes around ATM with LTP, IV, OI, volume)
• Technical scorecard: RSI, MACD signal, Bollinger Band position, SuperTrend direction, EMA crossover, ATR, support/resistance levels — scored into a consolidated buy/sell/neutral signal across multiple timeframes
• Market sentiment: VIX level + trend, PCR (put-call ratio), FII/DII net buy/sell for the day, Max Pain strike, OI buildup
• Current portfolio: open positions with unrealized P&L, current SL/target levels, available capital
• Context: market regime, session phase, DTE, and trade history for the day

Based on all this, it either proposes a specific trade (with strike, expiry, lots, order type, and written reasoning) or says "no opportunity, sitting out." The Checker then independently verifies.

Where I am now:

Just starting paper trading this week. All the infrastructure is built and tested (733 unit tests passing). The paper broker simulates realistic fills with multi-factor slippage (accounts for moneyness, VIX, time of day, symbol liquidity). Every trade gets logged to CSVs — entry/exit with full context, MFE/MAE (max favorable/adverse excursion), API costs, rejected trades, daily summary. Positions persist across restarts.

Planning to run 4-6 weeks of paper trading, collect data, then analyze:

• Is the win rate real or are prices not updating properly?
• Is the Checker actually adding value or just rubber-stamping?
• What's the actual API cost per day?
• Does the daily loss halt ever trigger?
• How does it behave on expiry days vs non-expiry days?

First live phase would be ₹5K test capital for a week, then scale to ₹1L if everything checks out.

My realistic targets (based on benchmarks from this sub):

Metric	Target	Why
Win rate	55-60%	Option buying has lower win rate than selling
Sharpe	1.0+	Anything above 1 is solid for retail
CAGR	20-30%	₹1L capital, buying only — no leverage magic
Max DD	<15%	Daily loss halt enforced by risk monitor
Trades/day	1-3	Quality over quantity, also keeps API costs down

I saw a post here recently about a NIFTY options selling strategy doing 38% CAGR with 1.3 Sharpe over 5.5 years — but that was ₹15L capital with selling. With ₹1L buying, I'm keeping expectations lower.

What keeps me up at night:

1. LLM consistency — Same market setup might get a different decision on different days. That's a feature (adapts) but also a risk (no backtestable edge). You can't really backtest an LLM strategy the traditional way.
2. Is the AI adding alpha or is the risk management doing all the work? — If I replaced Claude with random entry and just kept the trailing SL + daily loss halt, would results be similar? Hard to separate the two.
3. API costs — Running Claude every 15 minutes for 6+ hours = ~25 calls/day. Each call costs a few cents but it adds up over months. Currently tracking this to CSV.
4. Regime detection — The AI says "trending market, going long" but is it actually detecting regime or just pattern-matching to recent price action? No way to verify without months of data.
5. Real slippage — Paper simulates 0.3-1.5% slippage. Real expiry-day OTM options can have 3-5% spreads. That gap could eat all the alpha.

Questions for the community:

1. Has anyone used LLMs for actual F&O trading (not just backtesting/analysis)? What worked / what blew up?
2. Paper to live — what was the biggest surprise that paper trading completely failed to prepare you for?
3. ₹1L capital, option buying only — is 20-30% CAGR realistic or am I dreaming? What's a more honest number?
4. Any fundamental red flags in using a non-deterministic LLM vs a traditional backtested rule-based algo for live trading?
5. Kite Connect users — how reliable is the daily token refresh + WebSocket in practice? Any gotchas after months of running?
6. For those running algos 9:15-3:30 daily — what infrastructure issues bit you that you didn't expect? (Token expiry, rate limits, margin spikes, partial fills, etc.)

Not selling anything, no course, no channel, no GitHub link. Just a developer who wants experienced traders to poke holes in this before real money goes in. Roast away