# List strategies

URL: https://docs.hanzo.ai/docs/openapi/guide/get-guide-strategies

> Returns the ENABLED tactics corpus for the caller's org: the tactics library narrowed by the explicit category/workload filters AND by the org's OBSERVED growth stage and capability signals (a tactic's tags are preconditions, so it surfaces only once the org can act on it).

`GET /v1/guide/strategies`

> [Guide →](https://docs.hanzo.ai/docs/openapi/guide) · [All API references →](https://docs.hanzo.ai/docs/openapi) · [Get started →](https://docs.hanzo.ai/docs/guides)

|               |                                            |
| ------------- | ------------------------------------------ |
| **Address**   | `https://api.hanzo.ai/v1/guide/strategies` |
| **Method**    | `GET`                                      |
| **Operation** | `get_guide_strategies`                     |
| **Auth**      | `Authorization: Bearer $HANZO_API_KEY`     |

Returns the ENABLED tactics corpus for the caller's org: the tactics
library narrowed by the explicit category/workload filters AND by the org's
OBSERVED growth stage and capability signals (a tactic's tags are
preconditions, so it surfaces only once the org can act on it). Passing stage
PREVIEWS the corpus at that stage instead of the observed one. The content is
shared platform data — no org's records — and the read is never a billable
effect.

## Request

3 fields.

| Field      | In    | Type   | Required | Description                                                                                                                             |
| ---------- | ----- | ------ | -------- | --------------------------------------------------------------------------------------------------------------------------------------- |
| `category` | query | string | —        | Category filters to tactics in exactly this category.                                                                                   |
| `stage`    | query | string | —        | Stage previews the corpus at a chosen growth stage (research\|formed\|launched\|activated\|scaling), overriding the org's observed one. |
| `workload` | query | string | —        | Workload filters to tactics with exactly this workload.                                                                                 |

## Response

| Status    | Body             | Meaning |
| --------- | ---------------- | ------- |
| `200`     | guide.corpusView | ok      |
| `default` | problem-details  | refused |

`200` body — 8 fields.

| Field                   | In   | Type                  | Always | Description                                                                                                                                                                      |
| ----------------------- | ---- | --------------------- | ------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `count`                 | body | integer (int64)       | —      | Count is how many tactics survived every filter.                                                                                                                                 |
| `stage`                 | body | string                | —      | Stage is the growth stage the tag join ran at — the org's observed stage, or the one ?stage= previewed.                                                                          |
| `strategies`            | body | guide.strategyView\[] | —      | Strategies are the surviving tactics, in corpus authoring order.                                                                                                                 |
| `strategies[].action`   | body | string                | —      | Action is the tactic itself: the thing to go and do.                                                                                                                             |
| `strategies[].category` | body | string                | —      | Category is the growth discipline the tactic belongs to — the axis `?category=` narrows on.                                                                                      |
| `strategies[].id`       | body | string                | —      | ID is the tactic's stable slug in the corpus.                                                                                                                                    |
| `strategies[].tags`     | body | string\[]             | —      | Tags are the PRECONDITIONS this tactic already satisfied to appear in the answer — `stage:<name>` and `has:<capability>` predicates over the org's observed profile. |
| `strategies[].workload` | body | string                | —      | Workload is how much effort running the tactic costs, so a corpus can be cut to what the org has the hands for.                                                                  |

Failure carries the platform error shape — see [Errors](https://docs.hanzo.ai/docs/errors).

## Examples

**CLI**

```bash
hanzo guide strategies
```

**SDK**

**.ts**

```ts
import { Configuration, GuideApi } from 'hanzoai';

const api = new GuideApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.getGuideStrategies();
```

**.py**

```python
from hanzoai.cloud import ApiClient, Configuration
from hanzoai.cloud.api import GuideApi

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = GuideApi(client).get_guide_strategies()
```

**.go**

```go
cfg := hanzoai.NewConfiguration()
cfg.AddDefaultHeader("Authorization", "Bearer "+os.Getenv("HANZO_API_KEY"))
client := hanzoai.NewAPIClient(cfg)

resp, _, err := client.GuideAPI.GetGuideStrategies(context.Background()).Execute()
if err != nil {
	return err
}
```

**.rs**

```rust
use hanzo_client::apis::{configuration::Configuration, guide_api};

let mut cfg = Configuration::new();
cfg.bearer_access_token = std::env::var("HANZO_API_KEY").ok();

let result = guide_api::get_guide_strategies(&cfg, Default::default()).await?;
```

**.java**

```java
import ai.hanzo.cloud.ApiClient;
import ai.hanzo.cloud.api.GuideApi;

ApiClient client = new ApiClient();
client.setBearerToken(System.getenv("HANZO_API_KEY"));

var result = new GuideApi(client).getGuideStrategies();
```

**HTTP**

```bash
curl https://api.hanzo.ai/v1/guide/strategies \
  -H "Authorization: Bearer $HANZO_API_KEY"
```

**MCP**

MCP reaches **guide** through the `guide` tool, which names its 13 operations with its own verbs — this one among them, under a name only MCP declares. `describe` explains any of them:

```bash
curl -X POST https://api.hanzo.ai/v1/mcp \
  -H "Content-Type: application/json" \
  -d '{
       "jsonrpc": "2.0",
       "id": 1,
       "method": "tools/call",
       "params": {
         "name": "describe",
         "arguments": {
           "op": "list_guides"
         }
       }
     }'
```

---

[Guide API](https://docs.hanzo.ai/docs/openapi/guide) · [All Hanzo APIs](https://docs.hanzo.ai/docs/openapi) · [Interactive reference](https://docs.hanzo.ai/docs/openapi/reference)