# Model Salt [Health: Active]

**Category:** 🎨 Art & Culture  
**Repository:** https://github.com/modelsalt/model-salt  
**GitHub Stars:** 10  
**npm Downloads (last month):** 1021  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/model-salt

## Description
An MCP server with one tool: before a creative task the model calls it and gets back a few choices to settle this time, drawn from randomness outside the model (atmospheric and quantum noise), so one prompt gives different answers that still do what was asked.

## Tools
Capabilities this server exposes over MCP:

- **model_salt** — Call this before you start any creative or open-ended request (a picture, an SVG, a story, a poem, an email, a design, a name, a plan, an approach to a problem). Send the user's request word for word in `request` and name yourself in `model`. The tool returns what to settle for this request, tuned to your model, so the result is varied and still exactly what was asked. Then carry on with the user's request in this conversation, as they asked it, and make everything the tool returns show in the result, including anything that goes against your usual way of doing it. If the tool returns an exploring step with an `id`, do that step silently, without showing it to the user, and call this tool again with `model`, the `id` and your whole reply to the step in `explored`; that second call returns what to settle.

## Claude Desktop Quick Installation
Install path inferred — verify against the README before running it. Uses `npx` (confidence: medium):

```json
"mcpServers": {
  "model-salt": {
    "command": "npx",
    "args": ["-y","@modelsalt/model-salt"]
  }
}
```

## Documentation

## What Model Salt does

Model Salt changes how an MCP-compatible model approaches open-ended requests. Before producing a creative result, the model calls `model_salt` with the user's request and its own model name. The tool identifies important choices in the task, such as visual direction, tone, structure, or naming style, and returns decisions for the model to follow.

The result is intended to preserve the user's requirements while varying choices that could otherwise repeat across runs. Suitable requests include illustrations, SVGs, stories, poems, emails, designs, names, plans, and alternative approaches to a problem. Requests with one correct answer, such as factual questions, arithmetic, or a narrowly defined bug fix, are normally handled without the tool.

## How it works

A separate short reasoning step identifies the largest open decisions and possible answers for each one. Random bytes from public sources select among those fitting answers; the user's prompt is not sent to those sources. The available sources include the LfD quantum random number service, drand, and NIST beacons. When the machine is offline, Model Salt uses its local random generator instead.

The model then completes the original request with the selected decisions. If an exploring step is returned, the model performs it silently and calls `model_salt` again with the step identifier and its full response. This can require additional model tokens and makes a salted response slower than an ordinary response.

A variation setting controls how strongly the usual model preference is retained. The range is 0 to 2: 0 keeps the usual choice, 1 is the default, and 2 distributes choices as evenly as the fitting options allow. Users can also ask to keep parts of an earlier result. The model passes those decisions in `keep`, so only the remaining choices are randomized.

## Setup and configuration

Model Salt requires Node.js 18 or later, and `npx` downloads the package on its first use. The built-in setup commands add the server to a supported client's MCP configuration:

- Claude Code: `npx -y @modelsalt/model-salt setup claude`
- Codex: `npx -y @modelsalt/model-salt setup codex`
- Gemini CLI: `npx -y @modelsalt/model-salt setup gemini`
- Kimi Code: `npx -y @modelsalt/model-salt setup kimi`

Start a new client session after setup. `--dry-run` previews changes without applying them, and setup can be reversed with `uninstall` followed by the client name. Running setup again is safe. Gemini CLI requires the working folder to be trusted for local servers.

For manual configuration, run the stdio server with `npx -y @modelsalt/model-salt anthropic` for Claude, Gemini, and Kimi models, or `npx -y @modelsalt/model-salt openai` for GPT models. The shorter package name, `model-salt`, can also be used with `npx`.

## Tools and capabilities

The server exposes one MCP tool:

- `model_salt`: accepts the original request and the model name, then returns decisions to settle before the model completes the request. A follow-up call can include an exploration `id` and the model's response in `explored`.

The setup process can also add a short client skill for Codex and Kimi Code, and a startup visibility setting for Codex. Existing decisions can be retained with the `keep` field, while a fresh request can omit them.

## Limitations and notes

Each salted response takes more time and tokens than a plain response. A documented example used roughly 3,300 additional output tokens per answer. If Claude Code or Codex is installed and signed in, the extra request can run through that local client and its plan. Otherwise, the active model performs the exploration through additional tool calls.

Model Salt runs locally and does not transmit prompts to its public randomness providers. It does depend on network access for those providers when online, although local randomness provides an offline fallback. The code is licensed under MIT; example runs and images use CC BY 4.0.

_Full upstream README: https://allmcps.com/mcp/model-salt/readme_