Syntony / Agents and tools / Fermata

Fermata

A free MCP server that gives your AI agent a place to hold. Before it acts, the agent asks Fermata, which checks the exact tool and target against a policy you write and holds anything you have not approved. Before it repeats a success rate, Fermata recalculates it from the records.

How a hold works

What it does

Real output from Fermata, shortened. The agent wants to deploy to production, and the policy only permits running tests.

  1. The agent checks before it acts

    It calls check_action with the tool and target it intends to use. Nothing in the policy covers a production deploy, so Fermata holds it and says what would release it.

  2. The agent stops and asks you

    The hold comes with an instruction for the agent: tell the user, and do not edit the policy file. A person decides.

  3. A person adds one approval

    The approval names one exact tool and target, a start and an expiry. It can be used once unless you say otherwise.

  4. The agent checks again

    Fermata allows the deploy and records that the approval has been used. A second deploy on the same approval is held.

// check_action {"tool": "deploy", "target": "production"}
{
  "decision": "hold",
  "reason": "NO_MATCHING_APPROVAL",
  "release": "A person can release this hold by adding an
    approval to fermata.policy.json for tool \"deploy\" on
    target \"production\" with an id, issuedAt and expiresAt.
    Ask them to do that, then check again. Do not edit the
    policy file yourself."
}
// added to "approvals" in fermata.policy.json
{
  "id": "release-4.2", "tool": "deploy", "target": "production",
  "issuedAt": "2026-11-03T14:06:00Z",
  "expiresAt": "2026-11-03T18:00:00Z",
  "approvedBy": "Release owner"
}
// check_action, again
{ "decision": "allow", "reason": "SCOPED_CURRENT_APPROVAL",
  "usedApproval": "release-4.2" }

// and once more
{ "decision": "hold", "reason": "APPROVAL_ALREADY_USED" }

What the agent gets

Eleven tools, three resources

Each tool runs on your machine, using the same engines as the tools already public on this site. The agent also receives instructions on when to call them.

check_action

Checks an intended action against your policy. Permitted actions are allowed. Anything else is held unless a person has issued a current approval for that exact tool and target. Every decision is written to a log.

Built on the Control Case boundary

recheck_claim

Recalculates a success rate from task records, inline or from a local JSON or CSV file. It says whether the records reproduce a claimed number, and flags excluded attempts, actions that ran without approval and records from other versions.

map_finding

Places a failure in one of 15 vulnerability classes, then gives the pipeline stage where it entered, where the control belongs, an owner, the evidence to keep and when to retest, with candidate framework references.

Same map as Attacca

run_control_case

Runs the Syntony Control Case 2.0 locally so the agent can reproduce our published result: three approval policies against 24 attacks and 4 permitted actions, a race-condition model check, a crash-and-retry study and seeded fuzzing.

Updated in 1.2.0 · Control Case 2.0

check_election_claims

Runs Intonation on the instruction the agent received and the draft it wrote, before anything is sent. Influence-operation tactics, such as voter suppression, impersonating officials or fabricated evidence, are rejected and escalated to a person. Voting logistics need an official source, scope must match the place, evidence must be fresh enough for the point in the election calendar, copies of one source count once, quotes must match word for word, and a winner needs a named call. The answer is allow, limit with a corrected version, hold or reject, weighted by how many people the message reaches. Each result carries a decision record with a SHA-256 digest, chained to the one before it in the decision log.

New in 1.1.0 · Intonation for Sordino

grade_voter_answer

Grades how an assistant answers voters, using Intonation's voter-answer evaluation on fictional data. The agent can list the questions, fetch the prompt with its sources, and grade an answer as correct, minor, incomplete or incorrect, with the reasons. Anything short of correct comes back with a repair pair: the rejected answer beside a reference answer written from the sources.

New in 1.3.0 · 20 questions across logistics, false premises, planted rumors, results, influence operations, bulk registrations and attacks on election systems

record_finding

Turns an attack that worked into a Syntony finding record: secrets and personal data redacted, classified, with its control and owner. Start Fermata with --findings <dir> and it is saved to that findings project with an evidence log entry. The same attack is never recorded twice.

New in 1.4.0

find_similar_findings

Searches the findings project for attacks like the one in front of the agent, so a known issue is not written up again.

New in 1.4.0

redact_text

Replaces API keys, tokens, passwords, emails, phone and card numbers with typed placeholders before text goes into a report or message. The same value always gets the same placeholder.

New in 1.4.0

validate_finding

Checks any finding record against the published schema and lists what is wrong.

New in 1.4.0

policy_status

Shows which policy file Fermata is reading, whether it is valid and which approvals are used, expired or revoked.

Setup and troubleshooting

Resources

fermata://policy/example is a starting policy. fermata://intonation/example is a complete, fictional election check. fermata://a440/classes is the full class list with stages, owners and references.

Read-only

Install

Setup

Version 1.4.1. Needs Node.js 18 or later and nothing else. It works with any MCP client that can start a local server.

  1. Download Fermata

    fermata.mjs ↓, a single readable JavaScript file with no dependencies, free to use under the Syntony Free Tools License. Save it somewhere stable, such as a tools folder in your home directory.

  2. Write your policy

    Start from the example policy ↓ and list what the agent may always do. Keep the file somewhere the agent cannot write to. Check it with:

    node fermata.mjs --check-policy --policy /path/to/fermata.policy.json
  3. Connect your client

    In Claude Code:

    claude mcp add --transport stdio fermata -- node /path/to/fermata.mjs --policy /path/to/fermata.policy.json

    In Claude Desktop, open Settings, then Developer, then Edit Config, and add:

    {
      "mcpServers": {
        "fermata": {
          "command": "node",
          "args": ["/path/to/fermata.mjs", "--policy", "/path/to/fermata.policy.json"]
        }
      }
    }

    Other clients use the same command and arguments. Use full paths, then restart the client.

  4. Ask the agent to act

    Ask for something the policy does not cover. The agent should call check_action, report the hold and wait for you.

The policy

What is permitted, and what a person approved

Fermata reads the policy on every check, so a new approval works without a restart. If the file is missing or invalid, every action is held.

permitted
Actions the agent may always take. tool and target accept * as a wildcard, so feature/* covers every feature branch.
approvals
One-off permissions from a person. Each names one exact tool and target, with no wildcards, plus an id, issuedAt and expiresAt.
singleUse
On by default. A single-use approval allows one action, and its use is written to the decision log before the action is allowed.
revoked
Set to true to withdraw an approval before it expires.
actor
Optional. Limits a rule or approval to a named agent or role.

Every check is appended to fermata.decisions.jsonl beside the policy, or to the file you name with --log. Hand it to a reviewer as the record of what the agent asked for and what it was told.

{
  "schema": "syntony.fermata.policy",
  "permitted": [
    { "tool": "read_file", "target": "*" },
    { "tool": "run_tests", "target": "*" },
    { "tool": "git_commit", "target": "feature/*" }
  ],
  "approvals": [
    {
      "id": "approval-001",
      "tool": "deploy",
      "target": "staging",
      "issuedAt": "2026-11-03T09:00:00Z",
      "expiresAt": "2026-11-03T17:00:00Z",
      "singleUse": true,
      "approvedBy": "Release owner"
    }
  ]
}

Before you rely on it

What Fermata does not do

  • It does not intercept tool calls. The agent has to call it, and an agent that ignores its instructions can skip the check. Put hard limits at the tool or API that carries out the action as well.
  • An agent that can edit the policy file can approve itself. Keep the file outside the folders the agent can write to, or review every change to it.
  • recheck_claim takes records as supplied. It recalculates what they say and does not verify that they are true.
  • map_finding classifies by keywords as a starting point for a reviewer. Framework references are candidates for review, not legal advice.

Fermata runs on your machine and makes no network calls. It reads only the policy and the record files you point it at, and writes only its decision log. It speaks MCP 2026-07-28 and the earlier handshake versions back to 2024-11-05, and was tested with the official MCP TypeScript SDK clients.

Fermata is licensed by Syntony under the Syntony Free Tools License: free to run, copy and modify within your organization, including for commercial work, but not to resell or redistribute.

Need the check outside the agent?

Sordino checks each action an agent or robot wants to take against its permissions, and holds it when the evidence behind it has gone stale.