> ## Documentation Index
> Fetch the complete documentation index at: https://docs.doomberg.me/llms.txt
> Use this file to discover all available pages before exploring further.

# Starter Prompt

> The starter_research MCP prompt — its parameters, the full template text it returns, and ready-to-paste example prompts for your agent.

The starter prompt is a ready-to-use research directive you paste into your agent to kick off a full Ithaca research session. It tells the agent to follow the canonical workflow — open a session, research the market, propose a strategy, backtest it, and report — for a specific symbol and question.

## The starter\_research prompt

The starter prompt is parameterized by two inputs:

| Parameter  | Type   | Required | Description                                                                                              |
| ---------- | ------ | -------- | -------------------------------------------------------------------------------------------------------- |
| `symbol`   | string | yes      | The ticker to research (e.g. `NVDA`, `AAPL`, `TSLA`)                                                     |
| `question` | string | yes      | The research question or thesis to investigate (e.g. "Is now a good time to enter a momentum position?") |

## Full template text

When invoked, the starter prompt returns this template text for the agent to follow:

```text theme={null}
Research {symbol} using Ithaca and answer: {question}

Follow the canonical Ithaca workflow:

1. Call session_context with this prompt to open a traced research session.

2. Research {symbol} using data tools. At minimum:
   - market_get_ohlcv: pull 1 year of daily price history
   - market_screener: screen peers in the same sector
   - fundamentals_get: pull fundamentals metric cards
   - insider_activity: check SEC Form 4/5 insider transactions
   - congress_trades: check STOCK Act congressional trading disclosures
   - analyst_ratings: pull Wall Street consensus and price targets
   - technical_indicators: compute RSI, MACD, Bollinger Bands, ATR
   - vol_realized: compute annualized realized volatility

   Use search_skills to discover additional tools if you need them
   (e.g. options, sentiment, macro, short interest).

3. Synthesize your findings into a thesis. Note:
   - Price action and momentum vs. sector
   - Fundamental health (growth, margins, valuation)
   - Insider sentiment (net buy/sell)
   - Congressional trading signals
   - Analyst consensus and target upside
   - Technical levels (overbought/oversold, trend)
   - Volatility regime

4. Call propose_strategy with a declarative StrategySpec that captures
   your thesis. Use a closed-schema spec — no free-form fields, no code.
   Choose a strategy id (e.g. rank_returns, mean_reversion) and params
   that fit the regime you identified.

5. Call backtest_run with the validated spec and range="1y".
   If using hosted MCP, call run_skill with skill_id="backtest.run" instead,
   then subscribe_run to follow progress.

6. Report your findings to the human. Include:
   - Thesis summary
   - Key evidence (with provenance — note if any data is stale or partial)
   - Strategy spec (name, universe, signal, construction, risk limits)
   - Backtest results (CAGR, Sharpe, max drawdown, win rate, trade count)
   - Risk gate decision (pass/fail)
   - Recommendation and caveats

CONSTRAINTS:
- You can READ data and PROPOSE strategies. You cannot deploy or promote.
- Every tool call is traced. The human watches live in the Ithaca web UI.
- Strategies are declarative specs, not code. Never submit executable code.
- If a tool returns an error, report it and retry or pivot. Never fabricate data.
- Note the provenance of every data point (source, freshness, coverage).
```

## How to use it

<Steps>
  <Step title="Copy a prompt below">
    Pick an example prompt from the section below, or write your own using the template. Replace `{symbol}` and `{question}` with your target.
  </Step>

  <Step title="Paste it into your agent">
    Open Codex, Claude Desktop, Cursor, or whichever agent you installed Ithaca into. Paste the prompt. The agent will read the server instructions (from the MCP `initialize` response) and follow the canonical workflow.
  </Step>

  <Step title="Watch it live">
    Open [app.doomberg.me](https://app.doomberg.me) → **Sessions**. Your agent's research session streams live via SSE. Every tool call, argument, and result appears in real time.
  </Step>

  <Step title="Review the report">
    When the agent finishes, it posts a narrative report in the chat. Review the thesis, evidence, strategy, and backtest stats. If you want to promote the strategy to paper trading, do it from the web UI — the agent cannot.
  </Step>
</Steps>

## Example prompts

### Basic momentum research

```text theme={null}
Research NVDA using Ithaca and answer: Is the 60-day momentum thesis still intact, and should I backtest a monthly rebalanced long-only momentum strategy?

Follow the canonical Ithaca workflow:
1. Call session_context with this prompt.
2. Research NVDA: market_get_ohlcv (1y daily), market_screener (Technology sector),
   fundamentals_get, insider_activity, congress_trades, analyst_ratings,
   technical_indicators, vol_realized.
3. Synthesize a thesis.
4. Call propose_strategy with a rank_returns momentum spec (lookback=60, top=1,
   monthly rebalance, 5 bps cost).
5. Call backtest_run with range="1y".
6. Report findings with stats and a recommendation.
```

### Value + insider convergence

```text theme={null}
Research AAPL using Ithaca and answer: Are insiders buying while the stock is
cheap relative to fundamentals? If so, propose a mean-reversion strategy.

Follow the canonical Ithaca workflow:
1. Call session_context with this prompt.
2. Research AAPL: market_get_ohlcv, fundamentals_get, fundamentals_pit (point-in-time),
   insider_activity, institutional_holdings, analyst_ratings, technical_indicators.
3. Check if insiders are net buyers and if P/E is below sector median.
4. If the thesis holds, call propose_strategy with a mean_reversion spec
   (lookback=20, z-score entry, monthly rebalance).
5. Call backtest_run with range="2y".
6. Report findings. Note whether insider buying preceded price recoveries historically.
```

### Short squeeze screen

```text theme={null}
 Research GME using Ithaca and answer: Is there a short squeeze setup?
 Check short interest, days-to-cover, FTDs, and recent price action.

 Follow the canonical Ithaca workflow:
 1. Call session_context with this prompt.
 2. Research GME: market_get_ohlcv, short_interest, short_volume, short_ftd,
    short_screener, insider_activity, congress_trades, technical_indicators,
    vol_realized, market_tide (breadth).
 3. Assess squeeze risk: high short interest %, high days-to-cover, rising FTDs,
    technical breakout, volatility expansion.
 4. If a setup exists, call propose_strategy with a rank_returns momentum spec
    (short lookback=10, top=1, weekly rebalance) to ride the squeeze.
 5. Call backtest_run with range="6mo".
 6. Report findings. Flag the extreme risk profile and small sample size.
```

### Macro regime check

```text theme={null}
Research the market using Ithaca and answer: What is the current macro regime,
and which sectors should I tilt toward?

Follow the canonical Ithaca workflow:
1. Call session_context with this prompt.
2. Pull macro data: macro_dashboard, economic_calendar, vix_term_structure,
   commodity_prices, forex_rates, market_tide, market_movers.
3. Identify the regime (risk-on / risk-off / transition) from breadth, VIX shape,
   and commodity/FX moves.
4. Screen sectors using market_screener for the regime (defensive vs. cyclical).
5. Call propose_strategy with a sector-rotation spec over the top 2 sectors.
6. Call backtest_run with range="1y".
7. Report the regime, sector tilt, and backtest results.
```

### Options volatility trade

```text theme={null}
Research TSLA using Ithaca and answer: Is implied vol rich or cheap relative
to realized vol, and should I backtest a vol-selling strategy?

Follow the canonical Ithaca workflow:
1. Call session_context with this prompt.
2. Research TSLA: market_get_ohlcv, vol_realized, vol_term_structure, vol_vrp
   (variance risk premium), vol_iv_rank, vol_anomaly_score, vol_character
   (Hurst exponent), technical_indicators, options_greeks (for current ATM).
3. Assess: is IV > RV (vol expensive)? Is IV rank high? Is vol trending or
   mean-reverting (Hurst)?
4. If vol is rich, call propose_strategy with a mean_reversion spec that
   captures vol mean-reversion via the underlying.
5. Call backtest_run with range="1y".
6. Report the vol regime, VRP, IV rank, and backtest results.
```

## Tips for writing your own prompts

<Tip>
  Be specific about the **symbol** and the **question**. "Research NVDA" is too open-ended — the agent will pull everything. "Research NVDA and assess whether 60-day momentum is intact" gives the agent a clear thesis to test.
</Tip>

<Tip>
  Name the tools you want if you have a preference. The agent can discover tools via `search_skills`, but naming them (e.g. "check insider\_activity and congress\_trades") ensures they are included.
</Tip>

<Tip>
  Specify the backtest range. The default is `1y`, but for mean-reversion strategies a longer range (`2y` or `3y`) gives more regime diversity. For momentum, `1y` is usually enough.
</Tip>

<Tip>
  Ask for provenance in the report. The agent should note if any data is stale or partial — this is part of the server instructions, but reminding it ensures the report flags data quality issues.
</Tip>

## Related

<Card title="Agent Workflow" icon="route" href="/agent/workflow">
  The canonical workflow in detail — session\_context, research, propose, backtest, report.
</Card>

<Card title="MCP Tools" icon="wrench" href="/tools/overview">
  Browse the full 60+ tool catalog to name in your prompts.
</Card>

<Card title="Skills Catalog" icon="puzzle-piece" href="/skills/overview">
  Discover the 50+ data skills — market, fundamentals, congress, insider, vol, options, and more.
</Card>

<Card title="StrategySpec" icon="clipboard-list" href="/strategy/spec">
  The declarative strategy schema the agent assembles in step 4.
</Card>
