# Agent programs

Recipe360 reaches your agent in two parts: an **MCP server** that gives the agent its tools
(`recipe360 mcp`, over stdio) and a **skill** that tells the agent when and how to use them. Any agent program
that speaks MCP can use Recipe360; the ones below have been run end to end.

| Agent program | Tested | Models run through Recipe360 |
| --- | --- | --- |
| Claude Code | Yes | Claude Haiku 5.5, Sonnet 5.5, Opus 5.5 |
| Codex | Yes | gpt-6.1-sol, gpt-6-astra, gpt-6-luna |
| Hermes | Yes | Nemotron 3.5 Lightning 30B, gpt-oss-20b, MiniMax M3.1 Flash, Nemotron 3 Ultra 550B |
| Cursor | Not yet | The standard MCP setup below |

The Claude desktop app's chat and the ChatGPT desktop app's Work mode have each run the example end to end, with
the same delivery fingerprint; their sections are below. They are not part of the [measured results](results.md).

## When your agent installs it

Instead of using a terminal, you can ask your agent to install Recipe360 and connect it to itself; it asks
your permission before each command. The steps it follows:

1. Run the installer from the [quick start](quick-start.md). It ends by printing the full path of the
   `recipe360` command, usually `~/.local/bin/recipe360` (on Windows `%USERPROFILE%\.local\bin\recipe360.exe`).
   An agent that was already open does not find the command by name yet, so it uses that full path in every
   step below, settings included.
2. `recipe360 example`, then the run command it prints, as its own check that Recipe360 works: the answer ends
   with "Compliance verdict: compliant." and "Parameters: cutoff = 2026-10-31.", and the delivery fingerprint
   starts with `4989f850`. You do not need to do anything with the example.
3. If you gave it your licence key, `recipe360 activate <key>`; the example in step 2 runs without one. See
   [Your licence](licence.md).
4. It connects itself as the section for its program says below, with the full path as the command.
5. It tells you, in a few words, that Recipe360 is ready, and asks which process of yours you want to turn
   into a recipe. To start, open a new conversation: an agent sees new tools only in a new one (Codex may need
   to be closed and opened again). There, say what you do, for example "I want a recipe for our monthly
   overdue invoices; the file is in Downloads". If you would rather see Recipe360 work first, ask it to run
   the card portfolio review example.

## Claude desktop app

Install and activate Recipe360 first (the one-line installer, then `recipe360 activate` with your key). Then
download [recipe360.mcpb](https://recipe.pulso360.ai/download/recipe360.mcpb) and open it: the Claude app shows
an "Install" window, and Recipe360's tools appear in your conversations. The extension only tells the app how to
start the Recipe360 you installed (`~/.local/bin/recipe360 mcp`); it does not include Recipe360 itself.

This is how to use Recipe360 from the app's chat, without Claude Code. The chat has run the example and answered
with the closing message. Give Claude the full path of the data file or of its folder, for example
`/Users/you/Downloads/invoices.xlsx`; do not attach the file. An attached file is uploaded to the conversation,
where the model reads it, and Recipe360 cannot see it there.

## Claude Code and Cowork

The Recipe360 plugin connects the server and adds the skill in one step. Inside Claude Code:

```
/plugin install recipe360 --marketplace sebastianarangouribe-coder/recipe360-mcp
```

or from a terminal:

```bash
claude plugin marketplace add sebastianarangouribe-coder/recipe360-mcp
claude plugin install recipe360@pulso360
```

The plugin starts Recipe360 by name (`recipe360 mcp`), so install Recipe360 first and then open a new session.
In Cowork it works when the session runs on your computer. Its source is the public repository
[recipe360-mcp](https://github.com/sebastianarangouribe-coder/recipe360-mcp).

Without the plugin, for example when an agent that was already open connects itself with the full path:

```bash
claude mcp add --scope user recipe360 -- recipe360 mcp   # for every project; leave out --scope user for this one only
recipe360 skill --dest ~/.claude/skills                  # for every project; or .claude/skills inside one project
```

Use one way or the other, not both: with both, Claude sees Recipe360's tools twice. The Code tab of the Claude
desktop app also loads the Recipe360 desktop extension when it is installed, so there you need neither.

## Codex

In `~/.codex/config.toml`:

```toml
[mcp_servers.recipe360]
command = "recipe360"
args = ["mcp"]
cwd = "/Users/you"                        # your home folder: the Codex app needs a folder that exists
default_tools_approval_mode = "approve"   # optional: run Recipe360's tools without asking each time
```

Keep the `cwd` line. Without it, the Codex app starts the server in the conversation's folder, which may not
exist: the server then fails with "No such file or directory" and the model never sees Recipe360's tools.
With a full path as the command or the folder, write it in single quotes (`command = 'C:\Users\...\recipe360.exe'`)
so the backslashes of a Windows path stay as they are.

Codex reads skills from `~/.codex/skills` for every project, or from `.agents/skills` inside one project:
`recipe360 skill --dest ~/.codex/skills`.

## ChatGPT desktop app

The ChatGPT desktop app reads the same `~/.codex/config.toml` as Codex, so the block above connects it as well.
Use the full path of the command, as the installer prints it (`command = "/Users/you/.local/bin/recipe360"`):
an app opened from the Dock may not find `recipe360` by name. Keep the `cwd` line, then close the app and open
it again.

Recipe360 works in the app's **Work** mode and not in its **Chat** mode; the switch between them is at the top
of a new conversation. This is what happened with the example:

| Mode | What happened |
| --- | --- |
| Work, running "On your computer" | Ran the example and answered with the closing message |
| Work, running "In the cloud" | The same |
| Chat | Did not reach Recipe360: it could not see the folder and asked for the data as a ZIP file |

If ChatGPT asks you to upload your data, do not: the data would leave your computer, and Recipe360 would still
not run. Switch to Work and ask again. In the run record the app appears as Codex, the name it gives itself.

## Hermes

In Hermes's `config.yaml`:

```yaml
mcp_servers:
  recipe360:
    command: recipe360
    args: [mcp]
tools:
  tool_search:
    enabled: "off"     # Hermes otherwise hides MCP tools behind a search, and models may not find them
```

The skill goes in Hermes's skills folder: `recipe360 skill --dest ~/.hermes/skills`.

## Cursor and other MCP programs

Any program that starts an MCP server over stdio can use Recipe360. In Cursor, `.cursor/mcp.json`:

```json
{"mcpServers": {"recipe360": {"command": "recipe360", "args": ["mcp"]}}}
```

Give the agent the skill's text as standing instructions: `recipe360 skill` prints it.

## Which workspace

Recipes and runs live in `~/.recipe360` unless `RECIPE360_HOME` names another folder, or the server is started
with `recipe360 --home <folder> mcp`. One workspace per team or per client keeps their recipes and runs apart.

## The tools

| Tool | What it does |
| --- | --- |
| `recipe360_list` | The recipes in the workspace: what each needs, delivers and asks for |
| `recipe360_run` | Runs a recipe on a data folder, every step in one call; returns counts, the delivery fingerprint and the closing message |
| `recipe360_describe` | A recipe's steps in plain words |
| `recipe360_explain` | What happened to one record at each step, sensitive fields left out |
| `recipe360_check` | Checks a recipe without running it: errors, and every rule that can be read two ways |
| `recipe360_runs` | Past runs, newest first |
| `recipe360_record` | The record of a run: text, or a PDF, CSV or JSON file in the run folder |
| `recipe360_columns` | A data file's columns in order and how their values look (format, empty, different), without any value |
| `recipe360_guide` | The recipe format, for writing a new recipe |
| `recipe360_save` | Checks a recipe and saves it; a change needs a higher version, and the old one is kept |
| `recipe360_rules` | Every rule of a recipe in plain words, with the points to confirm with the person; with `confirm: true`, records that the person agreed, which lets the saved version run |
| `recipe360_test` | Runs a recipe on its test sample and compares every expected answer |

The tools forgive the usual slips of small models: a parameter passed beside the others, or the parameters
sent as text, still work. They never return rows of data. `recipe360_run` runs saved recipes only, and only
once the person has confirmed their rules, so a recipe cannot reach real data without the person's yes.

## Keep the data away from the model

Recipe360 never hands rows to the model. An agent program, though, has tools of its own (reading files, a
terminal, running code), and Recipe360 cannot see or stop what the model does with them. In our tests, some
models with every tool open opened the raw data themselves, to check it before a run or to verify the result
after it. The skill and the server now tell the model never to do that.

When the data is sensitive, also close the data folder in the agent program itself. The model then cannot read
it even if it tries, while Recipe360, which runs as its own process, still can. Each of these was tested with a
real recipe: the model could not read the folder, and the run was still correct.

| Agent program | How to close the data folder to the model |
| --- | --- |
| Claude Code | In `.claude/settings.json`: `{"permissions": {"deny": ["Read(//path/to/data/**)", "Bash"]}}` (two slashes start an absolute path) |
| Codex | In `~/.codex/config.toml`: `default_permissions = "recipe360"` and, under `[permissions.recipe360]`, `filesystem = { "/path/to/data" = "none" }` |
| Hermes | Run with Recipe360's tools only: `hermes -z "..." -t recipe360` |

With Hermes this also makes each run cheaper: with only Recipe360's tools, a run used about 12,000 tokens
instead of 44,000, because the model receives far fewer tool descriptions.