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

# Build a strategy

> Turn an investment thesis into a grounded, ranked list of companies using the Noonum REST API or MCP server.

A Noonum **strategy** turns an investment thesis into a grounded, ranked list of
companies. You write an **objective** describing the kind of companies you want exposure
to, and Noonum scores the companies that fit it, each with reasoning and evidence.

Each step below maps to a REST endpoint and an MCP tool.

<Note>
  **Prerequisites**
  Every call needs a Bearer token. See [Authentication](/v2/getting-started/authentication) for
  how to get one. The REST base URL is `https://api.noonum.ai/v2`; the MCP base URL is
  `https://api.noonum.ai/v1/mcp`.
</Note>

## The lifecycle at a glance

| Step | What you do               | REST                                                 | MCP tool                                 |
| ---- | ------------------------- | ---------------------------------------------------- | ---------------------------------------- |
| 1    | Sharpen the objective     | `POST /enhance-objective`, `POST /reverse-objective` | `enhance_objective`, `reverse_objective` |
| 2    | Check existing strategies | `GET /strategies?scope=public`                       | `list_strategies`                        |
| 3    | Create the strategy       | `POST /strategies`                                   | `create_strategy`                        |
| 4    | Submit for processing     | `POST /strategies/{id}/submit`                       | `submit_strategy`                        |
| 5    | Review holdings           | `GET /strategies/{id}/companies`                     | `get_strategy_companies`                 |
| 6    | Refine with exclusions    | `PATCH /strategies/{id}` + resubmit                  | `update_strategy` + `submit_strategy`    |

<Steps>
  <Step title="Write a good objective">
    The objective determines which companies get selected and how their relevance is scored.

    You author the objective yourself and submit it with `POST /strategies` (Step 3). Two
    helper endpoints can refine a draft first: `POST /enhance-objective` sharpens it and
    `POST /reverse-objective` flips it. Both are covered below.

    ### Format

    Always begin with **"The strategy is to invest in companies that are ..."** followed by a
    single paragraph describing the opportunities, products, themes, and value-chain segments
    you want exposure to.

    A strong objective is:

    * Specific: "...developing solid-state battery technology for electric vehicles", not
      "...in the energy sector".
    * Scoped to a clear value-chain segment, such as upstream suppliers, manufacturers, or
      end-market applications.
    * Theme-focused: describe the investment theme, not individual companies.
    * Product-oriented: focus on what companies do, build, or sell.

    Avoid:

    * Naming specific companies. Noonum finds them for you.
    * Generic sector labels with no thematic direction.
    * Overly broad framing that would match thousands of companies.
    * Negative framing. Use [exclusions](/v2/guides/iterate-strategy) for what you want to leave
      out.

    ### Examples

    ```text theme={null}
    Good:
    The strategy is to invest in companies that are building the physical and computational
    infrastructure for large-scale AI — data-center construction and cooling, high-bandwidth
    networking, GPU and custom-silicon design and fabrication, and power delivery for
    high-density compute.

    Too vague:
    The strategy is to invest in companies in the technology sector that benefit from AI.
    ```

    ### Sharpening a rough thesis

    If you start from a rough idea, expand it into a structured objective: keep the original
    intent and scope, then add value-chain segments and specificity around products,
    technologies, or business models. `POST /enhance-objective` (MCP: `enhance_objective`) does
    this for you: send a draft as `{ "objective": ... }` and it returns an `enhancedObjective`,
    an `improvementsSummary` describing what changed, and a `suggestedName` (see [Pick a
    name](#pick-a-name)).

    ```bash theme={null}
    curl -X POST "https://api.noonum.ai/v2/enhance-objective" \
      -H "Authorization: Bearer YOUR_TOKEN" \
      -H "Content-Type: application/json" \
      -d '{"objective": "invest in companies making AI chips"}'
    ```

    ### From an article

    To build from a news article, report, or post, pass the relevant text straight to
    `POST /enhance-objective`. Paste in an article you have, or fetch a page and pass its text.
    The endpoint reads the raw text and returns a focused `enhancedObjective`. A source with no
    identifiable investment theme is a poor one.

    ```bash theme={null}
    curl -X POST "https://api.noonum.ai/v2/enhance-objective" \
      -H "Authorization: Bearer YOUR_TOKEN" \
      -H "Content-Type: application/json" \
      -d '{"objective": "Demand for GLP-1 weight-loss drugs keeps outpacing supply, with Novo Nordisk and Eli Lilly expanding manufacturing and a wave of contract manufacturers, auto-injector suppliers, and oral-formulation startups racing into the supply chain."}'
    ```

    Over MCP, the `generate_strategy_from_content` prompt does the same from arbitrary text you
    pass in.

    ### Reverse objectives

    To create a thematic inverse (useful for hedging or pair trades), flip the directional
    exposure while keeping positive framing. Describe what the opposite side is rather than
    negating the original:

    | Original                    | Reverse                                    |
    | --------------------------- | ------------------------------------------ |
    | Renewable energy adoption   | Fossil fuel infrastructure                 |
    | Remote work technology      | Commercial real estate and office services |
    | Plant-based food innovation | Traditional livestock and meat processing  |

    `POST /reverse-objective` (MCP: `reverse_objective`) automates this: send the original as
    `{ "objective": ... }` and it returns a `reverseObjective` and a `reverseName` (see [Pick a
    name](#pick-a-name)).

    ```bash theme={null}
    curl -X POST "https://api.noonum.ai/v2/reverse-objective" \
      -H "Authorization: Bearer YOUR_TOKEN" \
      -H "Content-Type: application/json" \
      -d '{"objective": "The strategy is to invest in companies driving renewable energy adoption."}'
    ```

    ### Pick a name

    Noonum already suggests a name: `suggestedName` comes back from `POST /enhance-objective`,
    `reverseName` from `POST /reverse-objective`. Use either directly, or write your own.

    If you write your own, choose a descriptive name of 2–5 words with no "Strategy" suffix, for
    example "AI Infrastructure", "GLP-1 Weight Loss", or "Nuclear Renaissance".
  </Step>

  <Step title="Check what already exists">
    Check whether the strategy already exists. Noonum publishes a **public catalog** of
    strategies, and you may already have a similar strategy of your own.

    ```bash theme={null}
    # Public catalog of strategies
    curl -X GET "https://api.noonum.ai/v2/strategies?scope=public" \
      -H "Authorization: Bearer YOUR_TOKEN"

    # Your own strategies
    curl -X GET "https://api.noonum.ai/v2/strategies" \
      -H "Authorization: Bearer YOUR_TOKEN"
    ```

    Pass `scope=all` to get your own strategies plus the public catalog in one deduplicated
    list. Compare your objective against the names and objectives that come back. If a close
    match exists, reuse it as-is, copy it under a new name and objective, or proceed with a new
    strategy. Both calls are read-only, so listing alone is enough if you just want to browse.
  </Step>

  <Step title="Create the strategy">
    Create the strategy with your confirmed name and objective. Exclusions are optional here and
    can be added later once you've seen the holdings.

    ```bash theme={null}
    curl -X POST "https://api.noonum.ai/v2/strategies" \
      -H "Authorization: Bearer YOUR_TOKEN" \
      -H "Content-Type: application/json" \
      -d '{
        "name": "AI Infrastructure",
        "objective": "The strategy is to invest in companies that are building the physical and computational infrastructure for large-scale AI — data-center construction and cooling, high-bandwidth networking, GPU and custom-silicon design and fabrication, and power delivery for high-density compute.",
        "exclusions": []
      }'
    ```

    The response includes the new strategy's `id`, which you use to submit and to retrieve
    results.

    <Tip>
      **Name conflicts**
      If creation fails because a strategy with the same name already exists, list your
      strategies (`GET /strategies`) and pick a different name.
    </Tip>
  </Step>

  <Step title="Submit for processing">
    Creating a strategy stores its definition. **Submitting** runs the pipeline that finds and
    ranks companies, a job that can take several minutes.

    ```bash theme={null}
    curl -X POST "https://api.noonum.ai/v2/strategies/{strategyId}/submit" \
      -H "Authorization: Bearer YOUR_TOKEN"
    ```

    <Note>
      Submitting does not generate a factsheet by default, which keeps each run fast while you build
      and refine. To produce one, pass `create_factsheet: true` in the submit body. You can also
      request it afterward with `POST /strategies/{strategyId}/factsheet`.
    </Note>

    The pipeline reports these stages, which a client can surface as progress:

    1. Initializing strategy processing
    2. Interpreting investment objective
    3. Contextualizing with billions of market data points
    4. Retrieving and ranking relevant companies
    5. Scoring alignment and exposure metrics
    6. Strategy is ready

    ### Submit and poll

    Submission returns a `status` you poll until the run finishes. `status` is a percent-complete
    value: `0` when the job has not started, `1`–`95` while it is in progress, and `100` when the
    strategy is ready. A negative `status` (`-1` or `-2`) means the run failed. Poll until
    `status` reaches `100`, then fetch results with the read-only endpoints below. Other guides
    refer back to this submit-and-poll loop.

    Practical notes:

    * Expect a slow call. A single submission can take up to \~10 minutes. Set your HTTP request
      timeout accordingly.
    * A timed-out request may still finish in the background. Once `status` reaches `100`,
      fetch results with the read-only endpoints below without resubmitting.
    * Submitting a strategy that is already processing is rejected. Wait for the in-flight run
      to finish or fail.

    Over MCP, `submit_strategy` wraps this submit-then-poll loop and emits standard progress
    notifications, so you call one tool and wait. See the
    [MCP server reference](/base/agentic/mcp-server) for the progress and timeout semantics.
  </Step>

  <Step title="Review the holdings">
    Once `status` reaches `100`, retrieve the strategy's ranked companies. Each row carries
    scoring and exposure metrics. Ask for reasoning to see why each company was included.

    ```bash theme={null}
    curl -X GET "https://api.noonum.ai/v2/strategies/{strategyId}/companies?includeReasoning=true" \
      -H "Authorization: Bearer YOUR_TOKEN"
    ```

    Review the inclusion reasoning for the top 5–10 companies to judge whether the objective
    landed where you intended. If the companies aren't what you expected, adjust the objective
    (make it more specific, better-scoped, or target a different value-chain segment) rather
    than reaching for exclusions.

    ### Tuning the results

    The companies endpoint takes two query parameters that shape what you get back:

    * `includeReasoning=true` adds the inclusion reasoning text to each company.
    * `scoringMinMarketCap` sets the minimum market cap (USD) for conviction scoring.
      Companies below the threshold receive a `convictionScore` of `0`. `convictionScore`,
      `linguisticBeta`, and `marketBuzz` are Noonum's thematic signals; see
      [Signals and scores](/base/concepts/signals-and-scores) for what each measures.

    To export the full list as CSV, request the companies endpoint in CSV form (MCP:
    `download_strategy_companies`).

    ### Empty results

    If a strategy comes back with no companies, the theme is probably too niche. Broaden the
    objective, or start from a related strategy in the public catalog.
  </Step>

  <Step title="Refine with exclusions">
    Exclusions are short phrases describing types of company to filter out. Base them on the
    companies you see in the holdings, after the run, not on blind theme-based guesses.

    Write each exclusion as a description of what a company is, not what it isn't:

    * 2–6 words per phrase.
    * Do not prefix with "exclude" or use negation.
    * Describe the company type directly.

    For example, to drop cloud-infrastructure names from the example strategy:

    ```json theme={null}
    {
      "exclusions": [
        "cloud infrastructure providers",
        "data center operators",
        "infrastructure-as-a-service providers"
      ]
    }
    ```

    Apply exclusions by updating the strategy, then resubmitting so the pipeline re-ranks with
    the new filter:

    ```bash theme={null}
    curl -X PATCH "https://api.noonum.ai/v2/strategies/{strategyId}" \
      -H "Authorization: Bearer YOUR_TOKEN" \
      -H "Content-Type: application/json" \
      -d '{
        "exclusions": [
          "cloud infrastructure providers",
          "data center operators",
          "infrastructure-as-a-service providers"
        ]
      }'

    curl -X POST "https://api.noonum.ai/v2/strategies/{strategyId}/submit" \
      -H "Authorization: Bearer YOUR_TOKEN"
    ```

    Then re-review the holdings (Step 5) to confirm the right companies were removed and the
    ones you wanted to keep remain.
  </Step>
</Steps>

## Where to go next

* Dig into per-company evidence with `GET /strategies/{strategyId}/companies/{companyId}`
  (`get_strategy_company`) or pull all reasoning at once with
  `GET /strategies/{strategyId}/evidences` (`get_strategy_evidences`).
* Pull historical snapshots of a strategy's holdings to study how the theme evolved.
* Drive the entire flow from an LLM client via the
  [Noonum MCP server](/base/agentic/mcp-server).