# Replace activation

URL: https://docs.hanzo.ai/docs/openapi/tool/put-tool-activation

> Switches tools on and off for the caller's org and project, and answers with the resulting activated set.

`PUT /v1/tool/activation`

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

|               |                                           |
| ------------- | ----------------------------------------- |
| **Address**   | `https://api.hanzo.ai/v1/tool/activation` |
| **Method**    | `PUT`                                     |
| **Operation** | `put_tool_activation`                     |
| **Auth**      | `Authorization: Bearer $HANZO_API_KEY`    |

Switches tools on and off for the caller's org and project, and
answers with the resulting activated set. It is the ONE write path that turns
skills, plugins and connectors into callable tools — an unactivated tool is
listed by discovery but refused 403 at dispatch. Activate is applied before
Deactivate, so a name in both lists ends up off. More than 256 toggles in one
request is refused 413.

Switching a skill (skill\_\<name>) or a tool of an MCP server the org registered
(\<server>\_\<tool>) changes what every agent run in the org carries, so it takes
an admin of the org or a SuperAdmin: a member naming one is refused 403 and
nothing in the request is switched. Every change is on the org's audit trail
before it is made, and one the trail cannot record is refused 503.

## Request

2 fields, body `application/json` (required).

| Field        | In   | Type      | Required | Description                                                             |
| ------------ | ---- | --------- | -------- | ----------------------------------------------------------------------- |
| `activate`   | body | string\[] | —        | Activate switches these tool names on for the caller's org and project. |
| `deactivate` | body | string\[] | —        | Deactivate switches these tool names off.                               |

## Response

| Status    | Body               | Meaning |
| --------- | ------------------ | ------- |
| `200`     | tool.activationSet | ok      |
| `default` | problem-details    | refused |

`200` body — 1 field.

| Field     | In   | Type      | Always | Description                                                            |
| --------- | ---- | --------- | ------ | ---------------------------------------------------------------------- |
| `enabled` | body | string\[] | —      | Enabled is every tool name activated for the caller's org and project. |

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

## Examples

**CLI**

```bash
hanzo tool activation replace
```

**SDK**

**.ts**

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

const api = new ToolApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.putToolActivation({ activate: ["<activate>"], deactivate: ["<deactivate>"] });
```

**.py**

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

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = ToolApi(client).put_tool_activation(activate=["<activate>"], deactivate=["<deactivate>"])
```

**.go**

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

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

**.rs**

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

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

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

**.java**

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

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

var result = new ToolApi(client).putToolActivation();
```

**HTTP**

```bash
curl -X PUT https://api.hanzo.ai/v1/tool/activation \
  -H "Authorization: Bearer $HANZO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
       "activate": [
         "<activate>"
       ],
       "deactivate": [
         "<deactivate>"
       ]
     }'
```

**MCP**

MCP reaches **tool** through the `tool` tool, which names its 17 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_tools"
         }
       }
     }'
```

---

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