Installing Sigrid Axis

Sigrid Axis consists of the Sigrid Axis MCP server and a set of skills. Both follow open standards, so Axis works in any agentic tool that supports MCP and skills. Installing it means connecting the MCP server, installing the skills, and adding the Guardrails instruction to your repository. In Claude Code, a plugin does all three in one step.

Prerequisites

• A Sigrid account with at least one system. The Guardrails check works on code that has not been published to Sigrid yet, but the other tools and skills read what Sigrid Core found in a published system.
• A Sigrid API token. See authentication tokens for how to create one.
• Your Sigrid customer and system names, which you can read off the Sigrid URL: sigrid-says.com/<customer>/<system>.

Install the Claude Code plugin

In Claude Code, one plugin installs the MCP server, the skills, and a hook that reminds the agent to run the Guardrails check. Run these commands:

/plugin marketplace add Software-Improvement-Group/agent-integrations
/plugin install axis@sigrid
/axis:setup

On first use, Claude Code asks for your Sigrid API token and stores it in your operating system’s keychain. The setup skill detects your Sigrid system and writes .sigrid/profile.md. Run it once in each repository and commit the file. For changing the token later and for the plugin options, see configuration.

We would also turn on auto-update: run /plugin, go to Marketplaces, select sigrid, and choose Enable auto-update.

To check that it works, ask for a Guardrails check. No findings means a pass:

Run the Sigrid guardrails quality check on <a file you changed recently>.

The plugin connects to sigrid-says.com only. For Sigrid On-Premise, see connecting an AI coding assistant.

Install in other agentic tools

Outside Claude Code, you set up what the plugin would install for you, in four steps. The same steps apply to Claude Code without the plugin.

1. Connect the MCP server

Every agentic tool that supports MCP can connect to the Sigrid Axis MCP server at https://sigrid-says.com/mcp. The snippets below name the server axis and send your Sigrid API token in an Authorization header.

Most tools can read the token from an environment variable, so it never ends up in a configuration file you might commit. Set SIGRID_TOKEN once, in your shell profile on macOS and Linux:

export SIGRID_TOKEN=<your_sigrid_token>

On Windows, run setx SIGRID_TOKEN <your_sigrid_token>. Restart the tool afterwards, so it picks up the variable. The change-feedback skill reads the same variable when it runs Sigrid CI. For the tools that can’t read a variable, you paste the token into the configuration. Keep that file out of version control.

Open the section for your tool:

{
  "inputs": [
    {
      "type": "promptString",
      "id": "sigrid-token",
      "description": "Sigrid API token",
      "password": true
    }
  ],
  "servers": {
    "axis": {
      "type": "http",
      "url": "https://sigrid-says.com/mcp",
      "headers": {
        "Authorization": "Bearer ${input:sigrid-token}"
      }
    }
  }
}

{
  "servers": {
    "axis": {
      "url": "https://sigrid-says.com/mcp",
      "requestInit": {
        "headers": {
          "Authorization": "Bearer <your_sigrid_token>"
        }
      }
    }
  }
}

copilot mcp add --transport http --header "Authorization: Bearer $SIGRID_TOKEN" axis https://sigrid-says.com/mcp

claude mcp add --transport http --scope user axis https://sigrid-says.com/mcp --header "Authorization: Bearer $SIGRID_TOKEN"

{
  "mcpServers": {
    "axis": {
      "url": "https://sigrid-says.com/mcp",
      "headers": {
        "Authorization": "Bearer ${env:SIGRID_TOKEN}"
      }
    }
  }
}

codex mcp add axis --url https://sigrid-says.com/mcp --bearer-token-env-var SIGRID_TOKEN

[mcp_servers.axis]
url = "https://sigrid-says.com/mcp"
bearer_token_env_var = "SIGRID_TOKEN"

gemini mcp add --transport http --scope user --header "Authorization: Bearer $SIGRID_TOKEN" axis https://sigrid-says.com/mcp

{
  "mcpServers": {
    "axis": {
      "httpUrl": "https://sigrid-says.com/mcp",
      "headers": {
        "Authorization": "Bearer $SIGRID_TOKEN"
      }
    }
  }
}

{
  "mcpServers": {
    "axis": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://sigrid-says.com/mcp",
        "--header",
        "Authorization: Bearer <your_sigrid_token>"
      ]
    }
  }
}

{
  "mcpServers": {
    "axis": {
      "url": "https://sigrid-says.com/mcp",
      "headers": {
        "Authorization": "Bearer <your_sigrid_token>"
      }
    }
  }
}

{
  "mcpServers": {
    "axis": {
      "serverUrl": "https://sigrid-says.com/mcp",
      "headers": {
        "Authorization": "Bearer <your_sigrid_token>"
      }
    }
  }
}

{
  "mcp": {
    "axis": {
      "type": "remote",
      "url": "https://sigrid-says.com/mcp",
      "headers": {
        "Authorization": "Bearer {env:SIGRID_TOKEN}"
      }
    }
  }
}

{
  "mcpServers": {
    "axis": {
      "url": "https://sigrid-says.com/mcp",
      "headers": {
        "Authorization": "Bearer ${env:SIGRID_TOKEN}"
      }
    }
  }
}

{
  "mcpServers": {
    "axis": {
      "url": "https://sigrid-says.com/mcp",
      "headers": {
        "Authorization": "Bearer ${SIGRID_TOKEN}"
      }
    }
  }
}

{
  "context_servers": {
    "axis": {
      "url": "https://sigrid-says.com/mcp",
      "headers": {
        "Authorization": "Bearer <your_sigrid_token>"
      }
    }
  }
}

{
  "mcpServers": {
    "axis": {
      "type": "streamableHttp",
      "url": "https://sigrid-says.com/mcp",
      "headers": {
        "Authorization": "Bearer <your_sigrid_token>"
      }
    }
  }
}

{
  "mcpServers": {
    "axis": {
      "type": "streamable-http",
      "url": "https://sigrid-says.com/mcp",
      "headers": {
        "Authorization": "Bearer <your_sigrid_token>"
      }
    }
  }
}

2. Install the skills

The skills command line tool installs them from GitHub, and it needs Node. Run this in the root of your repository:

npx skills add Software-Improvement-Group/agent-integrations --skill '*'

It asks which of your agentic tools to install the skills for, and --skill '*' installs every skill. Keep them together, because they hand work to one another: autofix, for example, reads the plan that diagnose writes. Run npx skills update to get new versions.

3. Set up your repository

Run the setup skill once in each repository. It records your Sigrid system in .sigrid/profile.md, which you commit. You can also write that file yourself, and edit it to change how the skills behave in your repository. See the Sigrid profile.

4. Add the Guardrails instruction

The agent only calls the Guardrails check when something tells it to. In Claude Code, the plugin’s hook does that. Everywhere else, including Claude Code without the plugin, this instruction does.

Put this text in AGENTS.md at the root of your repository, which Cursor, GitHub Copilot, Devin, and most other agentic tools read at the start of every session. It is the same text the Claude Code hook adds:

Principles: single responsibility, self-documenting code, simple control flow.
Before reporting done:
1. Run Sigrid guardrails_quality_check on changed production code (skip tests, docs, generated).
2. Fix all maintainability findings judged against the principles — skip only if the code already honors them; say which and why.
3. Security findings: fix if contained, otherwise flag to user.

In Claude Code without the plugin, put it in CLAUDE.md. To adjust the instruction to your codebase, see set up the quality gate.

Upgrade from the Sigrid AI Toolkit

The Claude Code plugin used to be called sigrid, installed from the sigrid-ai-toolkit marketplace. It is now axis, installed from the sigrid marketplace, and a few things changed along with the name.

1. Replace the plugin

Remove the old plugin and its marketplace:

/plugin uninstall sigrid@sigrid-ai-toolkit
/plugin marketplace remove sigrid-ai-toolkit

Then install the new plugin. If you had turned off one of the hook options, turn it off again, because they have new names: Nudge to run guardrails and Nudge to use architecture-explorer. See plugin options.

2. Update your permission allowlists

The MCP tools from the plugin have a new prefix, mcp__plugin_axis_axis__ instead of mcp__plugin_sigrid_sigrid__. If you pre-allowed the Sigrid tools in .claude/settings.json, .claude/settings.local.json, or your user settings, replace the old prefix with the new one:

{
  "permissions": {
    "allow": ["mcp__plugin_axis_axis__*"]
  }
}

Without this change nothing breaks, but the agent quietly starts asking for permission before every Sigrid tool call again.

3. Move your profile into the repository

The old plugin kept one profile per user, in ~/.claude/plugins/data/sigrid-sigrid-ai-toolkit/CLAUDE.md. Sigrid Axis keeps one per repository instead, in .sigrid/profile.md, committed so your team shares it. Run /setup in each repository. When it finds your old profile, it offers to copy the system that matches the repository, and it leaves the old file in place.

4. Learn the new skill names

The skills are now one skill per job, and an argument picks the model. They also stop earlier than before: they commit locally and write statuses to Sigrid, but they never push, open merge requests or pull requests, or open issues. See the skills reference for what each one does.

Reliability findings are new: triage-findings reliability and autofix reliability. The old architecture-drift still works for now, as an alias of change-feedback architecture.

Manual MCP configurations

If you connected the MCP server by hand, it keeps working as it is. The server name in your configuration is your own choice, so renaming it from Sigrid to axis is optional.