The agentic harness for
autonomous trading

Six primitives that give an LLM everything it needs to trade on your behalf — and nothing more than you've authorised.

Vibe Trade is a harness — a structured environment that lets a large language model reason about markets, act on your behalf, and accumulate judgement over time, without you having to babysit it.

The core insight is that LLMs are already capable of sophisticated market reasoning. What they lack is infrastructure: a live connection to the market, a sense of time, a memory that persists across sessions, a monitoring loop that doesn't cost a fortune, and a trust model that ensures nothing happens without your consent. Vibe Trade supplies all of it.

The result is a trading agent you can give a strategy to in plain English — and then leave alone.

What is Vibe Trade?

Vibe Trade is the backend for agentic trading. Just as infrastructure platforms give developers a database, auth, and storage without making them build those systems from scratch, Vibe Trade gives an AI trading agent a live market connection, a scheduling system, a strategy memory, an audit trail, a monitoring loop, and a permission gate — without you having to build any of it.

You describe what you want to trade and why. The agent figures out how. The harness makes sure it runs reliably, accountably, and only as far as you've permitted.

The Harness

The word "harness" is deliberate. A harness doesn't replace the horse — it channels its capability into something controllable, directed, and safe. Vibe Trade does the same for an LLM.

An LLM on its own is powerful but directionless for trading. It has no state, no time, no broker connection, no memory of what it did yesterday, and no guardrails on what it can do next. The harness provides all of that as a set of interlocking primitives. Remove any one of them and the agent either can't act, or acts without accountability.

How Primitives Connect

The six primitives aren't independent modules — they compose into a single runtime loop. Here is the path for an autonomous Playbook run:

Vibe Trade App

A local chat interface and automation harness that puts all six primitives in your hands — the fastest way to understand what these docs describe in practice.

Vibe Trade is a fully-featured AI trading agent built on the harness described in this documentation. Every primitive — Heartbeat, Triggers, Permissions, Playbooks, Learnings — is wired up and running. Install it, connect your Dhan account, and the full harness is live.

It's designed as an experience first. Talk to the agent, watch it reason in real time, approve or reject its trade suggestions, create Playbooks through conversation, and inspect every decision and the reasoning behind it.

GitHub: vibetrade-ai/vibe-trade

Install and run

$ vibetrade

✓ VibeTrade running at http://localhost:3001
  Click http://localhost:3001 if it doesn't open automatically

The browser opens automatically. Add your Anthropic API key and Dhan credentials at http://localhost:3001/settings.

The app runs entirely on your machine. Your API key, credentials, trade history, and Playbooks are stored in ~/.vibetrade/ and never leave your local environment.

What you can do with it

Requirements

Market Tooling

The bridge between the LLM and the market — the agent never reasons from stale training data.

An LLM's training data has a cutoff. It doesn't know today's price of SBIN, whether Nifty is up or down, what news broke this morning, or what positions you currently hold. Market Tooling fixes this by giving the agent 20 built-in tools that connect it to live market data and your broker — so every decision it makes is grounded in what's actually happening right now.

Broker tools

Vibe Trade ships with first-class support for Dhan. Additional brokers are on the roadmap. The API endpoints, request structures, and parsing logic are already handled. The agent calls plain-English actions; the primitive handles the broker-specific implementation.

Market data tools

Extensibility

The built-in tools cover the most common data needs, but every trader has their own edge — a proprietary screener, an internal backtesting engine, a Bloomberg terminal. Vibe Trade will support registering custom tools by defining an endpoint, credentials, and a capability description the agent can read.

Heartbeat

Continuous market monitoring without continuous LLM inference — a lightweight loop that wakes the agent only when something matters.

Keeping an LLM running 24/7 is prohibitively expensive. But trading conditions don't wait — a stock might hit your entry price at 2:15pm on a Tuesday, and if nothing is watching, the moment passes. Heartbeat decouples monitoring from reasoning. A cheap process watches constantly. The LLM only runs when a condition fires.

The tick

Heartbeat runs on a fixed interval — every 30 seconds during market hours, slower when the market is closed. On each tick:

Evaluation cost by condition type

The llm condition mode is what makes Heartbeat qualitatively different from a traditional rules engine. The agent can set instinct-based triggers — not just coded equations — and the cost of monitoring them stays negligible.

Triggers

The automation primitive — every autonomous action the agent takes originates from a trigger.

A trigger is a condition and an action. When the condition becomes true, the action fires. There are no separate concepts called "schedules" or "reminders" — a cron expression is just a time-based condition, and everything resolves to the same two questions: when should this run? and what should happen when it does?

Anatomy of a trigger

Every trigger has the same shape. Here is a real stop-loss trigger from a live intraday session:

{
  "id": "2da93e8b-59c1-4493-ab64-685840048aeb",
  "name": "HINDALCO Short — Stop Loss ₹964",
  "scope": "symbol",
  "watchSymbols": ["HINDALCO"],

  "condition": {
    "mode": "code",
    "expression": "quotes['HINDALCO'].lastPrice >= 964"
  },

  "action": {
    "type": "hard_order",  // executes instantly — no agent involved
    "tradeArgs": {
      "symbol": "HINDALCO",
      "transaction_type": "BUY",  // cover the short
      "quantity": 3,
      "order_type": "MARKET"
    }
  },

  "expiresAt": "2026-03-11T15:15:00+05:30",  // auto-cancels at EOD
  "context": "Stop loss for intraday short. Entry SHORT 3 shares @ ₹957.95. Cover if price hits ₹964.",
  "status": "active"
}

Condition modes

Action types

A real trigger stack — Aggressive Alpha

The full trigger architecture the agent registered for itself when running the Aggressive Alpha intraday Playbook — created automatically when positions were opened:

The agent registered all of these itself — from the per-position SL and target triggers to the portfolio-level guards. You described the strategy. The agent built the automation stack.

Permissions

The trust primitive — a code-level approval gate that ensures no money moves without recorded consent.

Giving an AI access to your trading account is a meaningful act of trust. The obvious failure mode is an agent that acts on your money without your knowledge. But there's a subtler failure mode: an agent that asks for permission in chat, you say "yes", and that's treated as authorisation. That's gameable, ambiguous, and not a real record of consent.

The core principle: no trade can be placed without explicit, recorded consent. What consent looks like depends on how much autonomy you've chosen to give the agent.

The approval gate

Every reasoning_job that wants to place a trade must submit a request to the approval gate. The agent cannot bypass this. Even when it has concluded a trade is the right move, it can only queue the request — not execute it.

The request arrives as a structured approval card: the exact trade, the full reasoning behind it, and the context that led to the decision. Here is a real card from a live session — the agent's recommendation to exit a short ONGC position:

This is not a chat confirmation. It is a timestamped, structured record — linked to the Playbook, the trigger that fired, and the agent's reasoning at the moment of decision.

Three levels of consent

hard_order and the pre-authorisation model

Some triggers bypass the approval queue entirely. A hard_order trigger — used for stop-losses and price targets — executes the moment its condition is met, with no agent involvement and no approval step. This is by design: a stop-loss that waits for your phone tap is not a stop-loss.

The consent for a hard_order is given when you create the trigger. At that point you're specifying the exact condition and the exact trade. The execution is just the fulfilment of a decision you already made.

Playbooks

The agent's operating manual — a written strategy document that anchors every decision made on its behalf.

Every new LLM session starts from zero. Without a Playbook, ask the agent whether to buy Infosys today, close the tab, ask again tomorrow — and you might get a different answer. One instance looks at volatility and says wait. Another looks at fundamentals and says buy. Neither is wrong, but neither is yours. There's no consistent thesis, no discipline, no record of what you were trying to achieve.

A Playbook is the document that fixes this. It is a written strategy that the agent receives as context on every run — whether triggered by a schedule, a price condition, or a live chat. The agent reasons as: "I am running this Playbook. These are my rules. Given what I can see right now, here is what I should do."

What a Playbook contains

A Playbook is a markdown document. There is no rigid schema — you write it the way you'd brief a portfolio manager. In practice, effective Playbooks cover four things:

You don't write this from scratch. You describe your intent in plain English, the agent helps you shape it into a document, and once you agree — it becomes the operating manual.

What a Playbook adds

Playbook record

The actual Playbook record for Aggressive Alpha — the live intraday strategy used throughout these docs:

{
  "id": "84f56962-0f6b-4d71-b1ec-4c9721f88fdb",
  "name": "Aggressive Alpha",
  "description": "Aggressive intraday long/short momentum strategy trading up to 3 concurrent positions across Nifty 100 stocks, always keeping capital deployed.",
  "allocation": 9000,
  "state": "scanning",  // updated by the agent after each run
  "status": "active",
  "plan": "## Aggressive Alpha — Intraday Long/Short Momentum Strategy\n\n...",
  "createdAt": "2026-03-10T17:09:16.796Z",
  "updatedAt": "2026-03-11T07:31:15.671Z"
}

Learnings

The agent's audit trail and compounding memory — an immutable record of every trade, every decision, and everything distilled from both.

LLMs don't naturally remember what they did. Ask an agent why it bought a stock last Tuesday and it may confabulate a reason, or simply not know. This is a foundational problem when AI is acting on your money: you need a ground truth it can't rewrite.

Beyond accountability, there's a compounding problem: without a record of what worked and what didn't, the agent makes the same mistakes indefinitely. Learnings solves both.

The trade journal

Every order placed through Vibe Trade is written to an immutable trade record. Each entry captures what happened, when, and — critically — why the agent decided to act. Here are real entries from a live session:

[
  {
    "id": "6b2029a0-81e1-443f-85cd-e9f377182391",
    "symbol": "ONGC",
    "transactionType": "SELL",
    "quantity": 11,
    "executedPrice": 269.00,
    "status": "filled",
    "strategyId": "84f56962-0f6b-4d71-b1ec-4c9721f88fdb",
    "note": "Aggressive Alpha — Slot B SHORT. Below VWAP all session, RSI 45 falling, MACD negative, weak oil sector on bearish day. SL: ₹273.04, Target: ₹262.28",
    "filledAt": "2026-03-11 10:19:12"
  },
  {
    "id": "0c616b25-8f1b-4ea1-a2b8-4ddf3c4e0621",
    "symbol": "COALINDIA",
    "transactionType": "BUY",
    "quantity": 5,
    "executedPrice": 446.90,
    "status": "filled",
    "strategyId": "84f56962-0f6b-4d71-b1ec-4c9721f88fdb",
    "note": "Aggressive Alpha — Slot C LONG. Gapped up at open, holding above VWAP, RSI 56 with room to run, MACD positive. SL: ₹440.00, Target: ₹457.77",
    "filledAt": "2026-03-11 10:19:14"
  }
]

The note field is written by the agent at the moment of entry — the reasoning it used to make the decision, not a post-hoc summary. Every trade is auditable back to the exact thesis the agent was running at the time.

Playbook-level vs. global

Every record is tagged. Trades, trigger runs, and observations are all linked to the Playbook they belong to — or marked global if they weren't part of one. The agent can filter its entire history by Playbook: show me everything Aggressive Alpha did.

Compounding edge

At the end of each trading day, the agent reviews its history — reading through the trades placed, the reasoning written at the time, and the outcomes — and distils learnings from that review. These feed forward. A learning might propose tightening an entry condition, adjusting a rebalancing cadence, or flagging a pattern the agent kept getting wrong. Proposed changes require your approval; the agent does not edit the Playbook unilaterally.

Skills

Reusable instruction modules that personalise how the agent behaves for specific tasks — loaded when relevant, ignored when not.

A Playbook defines what you're trying to achieve. A Skill defines how you like a specific recurring task done. Where a Playbook is the strategy, a Skill is the technique.

If you have a particular way of sizing positions, a checklist you run before entering a momentum trade, or a preference for how exit reasoning gets presented — that's a Skill. You write it once, and the agent reaches for it whenever that task comes up.

What a Skill looks like

A Skill is a markdown file: a name, a description the agent uses to decide when to reach for it, and the instruction content itself. The format is identical to Claude's skill files — intentionally familiar.

---
name: position-sizing
description: How I calculate position size for intraday trades. Use this
             whenever you need to determine quantity for a new entry.
---

Always size by risk, not by capital.

1. Determine the stop-loss distance in rupees (entry price - SL price for longs)
2. Risk per trade = 1% of available capital
3. Quantity = risk per trade / stop-loss distance, rounded down
4. Minimum 1 share. If quantity rounds to 0, skip the trade.
5. Never exceed 25% of available capital in a single position, regardless
   of what the formula gives you.

For intraday trades, always use INTRADAY product type. Never CNC.

How Skills are loaded

This mirrors how Skills work in Claude Code: you configure which Skills are available per project, and the model decides when they're relevant. Attach Skills to a Playbook the way you load Skills into a project.

Primitives at a Glance

Full Data Flow

How a complete autonomous Playbook run flows through all the primitives — from Heartbeat tick to executed trade. This is a real session: Aggressive Alpha, 11 March 2026.