Coding agents

The OneHot plugin teaches coding agents such as Claude Code, Codex and Cursor to build with the OneHot API. The agent learns to write decisions, act on the probabilities, train models and handle errors. For current details, the plugin points it to these docs.

Install the plugin

Set SQWISH_API_KEY to a key from the console first.

Claude Code
Other agents
Ask your agent

claude plugin install onehot --marketplace sqwishai/onehot-agent

This needs Claude Code 2.1.292 or later. With an older version, add the marketplace first:

claude plugin marketplace add sqwishai/onehot-agent
claude plugin install onehot@sqwish

Restart Claude Code and type /mcp to check that onehot is connected.

npx skills add sqwishai/onehot-agent --skill onehot

Add -g to install it for every project. This installs the skill. Connect the MCP server with the steps for your agent below.

Paste this into your agent:

Install the OneHot skill from https://github.com/sqwishai/onehot-agent with one of these two
commands, not both. In Claude Code, run
`claude plugin install onehot --marketplace sqwishai/onehot-agent`. In any other agent, run
`npx skills add sqwishai/onehot-agent --skill onehot`, then connect the MCP server at
https://api.sqwish.ai/mcp with the API key from the SQWISH_API_KEY environment variable,
following https://docs.sqwish.ai/agent-skills#connect-through-mcp for this agent. Never
write the key itself into a file. If neither command works here, read
https://github.com/sqwishai/onehot-agent/blob/main/skills/onehot/SKILL.md and follow it.

Install it one way only, or your agent loads two copies of the skill. With the Claude Code plugin, remove any OneHot MCP connection you added to Claude Code by hand. Otherwise it sees every tool twice. With the skill alone, including in Codex or Cursor, keep the MCP connection you added by hand. The skill is on GitHub to read or to copy by hand.

Keep it up to date

The skill follows the API. An old copy can lead your agent to send fields the API no longer takes. Claude Code leaves auto-update off for marketplaces that Anthropic doesn’t run, so turn it on once: type /plugin, open Marketplaces, choose sqwish, then Enable auto-update. To update by hand, run claude plugin update onehot@sqwish. In other agents, run npx skills update onehot.

Example prompts

Say “using the OneHot skill” so any agent loads it. In Claude Code you can also run /onehot:onehot.

Find fragile code

Using the OneHot skill, find where this project classifies text with string matching, regular expressions or by parsing a language model’s reply, and propose OneHot decisions to replace them.

Build a feature

Using the OneHot skill, route incoming support tickets to billing, technical or other, and send a ticket to a person when no team gets at least 0.6.

Tune the wording

Using the OneHot skill, lint my decisions, then try them on the labelled examples in tickets.jsonl and tell me which wording and threshold work best.

Train your own model

Using the OneHot skill, quote a fine-tune on tickets.jsonl, start it if it costs under $5, and report the gate as it is.

What OneHot’s MCP does

Endpointhttps://api.sqwish.ai/mcpStreamable HTTP · Bearer API key

MCP is a way for an assistant to call tools. You give it one address. It reads the tools that address offers and calls one when the task needs it. OneHot’s server offers decision tools. Ask which tickets need a refund, and how sure the model is, and the agent can call decide on each one. The answer is a probability for every outcome you allowed. The model does not write a reply, so it cannot invent an outcome that is not on your list. A person can score text from the chat. A coding agent can check a decision, quote it and run it while it works. The key, the errors and the charges are the same as on the HTTP API. The calls spend credit from the account that owns the key.

Connect through MCP

The plugin connects Claude Code for you. Connect by hand for Codex and Cursor, or to use the tools without the skill. Connect one way only, or the agent sees every tool twice. Each tool is one call to the HTTP API, with the same key and the same errors. A key with inference access can decide, read models and families, and use lint_decision and list_recipes. Its calls to the other tools get 403 key_scope. The endpoint accepts POST only and returns 405 to a GET. The tools use your account. They can spend credit, including by keeping a model warm. Approve those calls in the client.

Claude Code
Codex
Cursor

Run this once. To share the server with your team, add --scope project, which writes .mcp.json. Then write the header as 'Authorization: Bearer ${SQWISH_API_KEY}', in single quotes and with braces, so the file holds ${SQWISH_API_KEY} and not the key.

claude mcp add --transport http onehot https://api.sqwish.ai/mcp \
  --header "Authorization: Bearer $SQWISH_API_KEY"

Then type /mcp in Claude Code and check that onehot is connected.

This writes [mcp_servers.onehot] to ~/.codex/config.toml.

codex mcp add onehot --url https://api.sqwish.ai/mcp \
  --bearer-token-env-var SQWISH_API_KEY

Add this to .cursor/mcp.json for one project, or ~/.cursor/mcp.json for every project.

{
  "mcpServers": {
    "onehot": {
      "url": "https://api.sqwish.ai/mcp",
      "headers": {
        "Authorization": "Bearer ${env:SQWISH_API_KEY}"
      }
    }
  }
}

The commands above read your key from SQWISH_API_KEY. To test the connection, ask the agent to list models. It should call list_models and report which are available.

The tools

Start with list_recipes for a complete request. Use lint_decision to check the wording and estimate_decide for the quote. Then call decide. The tools take text only. To ask about pictures, have the agent write code that calls the API (Images). A fine-tune’s model joins its family only when its gate passes. A family that is switched on then moves to it (how a family moves).

Decide
Improve
Families and models

Tool	What it does
`list_recipes`	Ready-made decisions, each with a complete request.
`lint_decision`	Warnings about the wording. No model runs.
`estimate_decide`	Billed input and the maximum charge. No inference, and no credit held.
`decide`	Probabilities and an action. Charges once. Send the same `idempotency_key` if you retry. Under zero data retention the key isn’t honoured, and a retry is charged again.
`list_models`	Base models and your fine-tuned models, each with its own switch (`on_at`).
`get_model`	One model by its number, such as `router@3`: its gate, switch, keep warm and state. For a base model, its limits.
`model_ready`	Whether a model can run decisions now, and if not, why. Costs nothing.

Tool	What it does
`create_dataset`	A training dataset from labelled examples. It does not start training.
`add_dataset_rows`	Adds labelled rows as the dataset’s next version. They must ask the dataset’s own decisions, unless `allow_new_decision_ids` lets them ask new ones too.
`list_dataset_versions`	A dataset’s versions, newest first, with the rows each added.
`create_family`	Starts a new family with its first training job. Poll `get_fine_tune` and read `metrics.gate`. A model that passes joins the family, and a family that is switched on moves to it.
`estimate_family`	The exact fee of `create_family` for the same arguments. Nothing starts, and no credit is held.
`continue_family`	Trains a family’s next model from its latest one, on the dataset’s new rows.
`estimate_continue`	The exact fee of `continue_family` for the same arguments. Nothing starts, and no credit is held.
`get_fine_tune`	A fine-tune’s status, output model and held-out metrics.

Tool	What it does
`list_families`	Your families, each with its switch, the model it serves, its latest model and any move it waits to make.
`get_family`	One family: its dataset, its line of models, its jobs, and what continuing it would do now.
`switch_family`	Switches a family on or off. On, it answers calls to its name with its latest model.
`switch_model`	Switches a model’s own switch. On, it answers calls to its number.
`keep_family_warm`	Keeps the model a family serves loaded between requests.
`keep_model_warm`	Keeps one model loaded, while its own switch is on.
`roll_back_family`	Takes a family back to an older model and discards every newer one.
`delete_family`	Deletes a family, with every model of its line.
`delete_model`	Deletes one model for good.

decide, create_family and continue_family spend credit. So do keep_family_warm and keep_model_warm, where keep warm is billed. Switching, rolling back and deleting change what answers your calls. The tools that switch, keep warm, roll back or delete tell the agent to ask you first.

Claude Code tool-call hook

POST /v1/hooks/claude-code is a separate check on Claude Code PreToolUse payloads. It returns allow, ask or deny. Each check is a decision, charged like any other. The default, mode=guard, never grants permission. mode=auto can allow, which skips Claude Code’s permission prompt. If the model isn’t sure, or scoring fails after the request is accepted, the hook asks the person. To turn it on, add this to .claude/settings.json in your project, or to ~/.claude/settings.json for every project. Then set SQWISH_API_KEY before you start Claude Code. Keep the timeout short. If the hook does not answer in time, Claude Code asks you as it normally would. mode is a query parameter: for mode=auto, add ?mode=auto to the hook’s URL.

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "*",
        "hooks": [
          {
            "type": "http",
            "url": "https://api.sqwish.ai/v1/hooks/claude-code",
            "headers": {"Authorization": "Bearer $SQWISH_API_KEY"},
            "allowedEnvVars": ["SQWISH_API_KEY"],
            "timeout": 5
          }
        ]
      }
    ]
  }
}

Keep your own permission checks as well. The tool-risk recipe is the decision, and the hook route is the payload. Errors explains each status code, whether to retry it and whether it is charged.

Files an agent can read

Two files on the API host tell an agent how to use OneHot. Fetching them needs no account.

openapi.json

The machine-readable contract: routes, bodies, and responses. It matches the API reference tab.

llms.txt

A short guide to authentication, decisions, and the workflows around them. It links to the OpenAPI document.

https://api.sqwish.ai/openapi.json
https://api.sqwish.ai/llms.txt

These docs also come as Markdown files: a page index and the full text.

Common problems

The agent doesn't use the skill

Run /onehot:onehot in Claude Code, or say “using the OneHot skill”. Check that the skill is installed for your agent, then restart it.

/mcp says onehot failed

Start the agent from a shell where SQWISH_API_KEY is set. api_key_required means the agent sent no key. Signing in to the console doesn’t count. invalid_api_key means the key is wrong or revoked. Make another one in the console.

The agent invents request or response fields

The skill is out of date. Update it and try again.

Answers don't match what you expect

Describe each outcome more precisely, and give a way out such as “other”. Pick thresholds on examples whose answers you know. lint_decision flags the common mistakes.

Questions

Where does an agent find the OpenAPI document?

At https://api.sqwish.ai/openapi.json. Fetching it needs no key. llms.txt on the same host is the short guide, and it links to that file.

Which key does MCP use?

The same API key as the HTTP API, sent as Authorization: Bearer. Create it in the console.

Will the agent change production on its own?

Only when you approve a tool that changes what answers: a switch, a rollback or a delete. If the gate passes, a family it starts or continues for you moves to the trained model by itself. Any family that is switched on does the same.

What if /mcp does not respond?

Use https://api.sqwish.ai/mcp. The endpoint accepts POST only, with Authorization: Bearer and an API key from the console. If the client cannot connect, call the HTTP API from the OpenAPI document directly.

Get started

Make decisions

Improve accuracy

Use the API

Account and billing

Privacy and security

Integrations

Install the plugin

Keep it up to date

Example prompts

What OneHot’s MCP does

Connect through MCP

The tools

Claude Code tool-call hook

Files an agent can read

openapi.json

llms.txt

Common problems

Questions