Skip to main content
Agent skill

Reliant Config

Configure Reliant — memory files, skills, MCP servers, presets, and config YAML. Use when adding instructions, creating or updating skills, connecting tools, or customizing agent behavior.

All install options
Quick install · Personal (~/.claude/skills)Project / Cursor / Desktop →
mkdir -p ~/.claude/skills/reliant-config && curl -fsSL 'https://raw.githubusercontent.com/reliant-labs/reliant/main/internal/skills/catalog/builtin/reliant-config/SKILL.md' -o ~/.claude/skills/reliant-config/SKILL.md

Get the complete skill folder, including its scripts and reference files.

When to use this skill

Use Reliant Config when an AI agent needs a reusable SKILL.md workflow for this job: Configure Reliant — memory files, skills, MCP servers, presets, and config YAML. Use when adding instructions, creating or updating skills, connecting tools, or customizing agent behavior.

When not to use it

Skip Reliant Config when the task is outside the coding category, or when a more specific skill in this directory already covers the same workflow with clearer triggers.

How to install

Where will you use it?

Install scope
One-line install (Claude Code)
mkdir -p ~/.claude/skills/reliant-config && curl -fsSL 'https://raw.githubusercontent.com/reliant-labs/reliant/main/internal/skills/catalog/builtin/reliant-config/SKILL.md' -o ~/.claude/skills/reliant-config/SKILL.md
  1. Claude Code personal install: place the skill and its bundled files at ~/.claude/skills/reliant-config/SKILL.md. For a shared project, commit the folder at .claude/skills/reliant-config/ instead.
  2. Current Claude Code detects SKILL.md changes in watched directories during the session. If you just created a top-level skills directory, run /reload-skills. Check that the skill is listed before testing its trigger.
  3. For Claude chat or Cowork in the Desktop app, manage uploaded skills in Customize > Skills; copying files into a local Claude Code folder is not a Desktop install. Other agents may use different install locations.

Full install guide for Claude, Cursor, and Codex →

Try a starter prompt

After installing the skill, paste this starter prompt into your agent to verify it triggers on a small task.

Starter prompt
Use the Reliant Config skill for this task: When deploying to staging or production. Confirm any required inputs or files before making changes.

What supports this recommendation?

75/100 provisional content score. This measures documentation, practical detail and source signals. It is not a measured task success rate or a security certification.

Documentation
82/100
Practical detail
80/100
Source evidence
58/100
Source signals
72/100
Model compatibility evidence
  • claudeinferred

    The skill text mentions Claude or a closely associated term. This is keyword-derived compatibility; no hands-on model test is recorded.

  • chatgptinferred

    The skill uses model-agnostic prompt or LLM terminology. Portability is inferred and has not been verified on this model.

  • geminiinferred

    The skill uses model-agnostic prompt or LLM terminology. Portability is inferred and has not been verified on this model.

  • copilotinferred

    The skill uses model-agnostic prompt or LLM terminology. Portability is inferred and has not been verified on this model.

  • llamainferred

    The skill uses model-agnostic prompt or LLM terminology. Portability is inferred and has not been verified on this model.

  • perplexityinferred

    The skill uses model-agnostic prompt or LLM terminology. Portability is inferred and has not been verified on this model.

  • mistralinferred

    The skill uses model-agnostic prompt or LLM terminology. Portability is inferred and has not been verified on this model.

  • grokinferred

    The skill uses model-agnostic prompt or LLM terminology. Portability is inferred and has not been verified on this model.

Inferred compatibility is based on content signals. Check the app, its available tools and setup requirements before running a skill.

What this skill does

# Reliant Configuration

Use this skill to configure any aspect of Reliant: memory/instructions, skills, MCP servers, presets, or config YAML.

## Scope model

Reliant uses three configuration scopes, merged with higher priority winning:

| Scope | Location pattern | Git behavior | |-------|-----------------|--------------| | **Global (user)** | `~/.reliant/` | N/A (user home) | | **Project** | `<project>/.reliant/` | Committed to git | | **Local** | `<project>/.reliant.local/` | Gitignored |

This pattern repeats across all config types. Local always wins over project, which wins over global.

---

## 1. Memory system (reliant.md)

Memory files inject persistent instructions into every LLM call as "User defined rules, memories, and context."

| File | Scope | Git | |------|-------|-----| | `~/.reliant/reliant.md` | Global — applies to all projects | N/A | | `<project>/reliant.md` | Project — committed, shared with team | Committed | | `<project>/reliant.local.md` | Local — personal, gitignored | Gitignored |

**Precedence:** All three are merged (not overridden). Global loads first, then project, then local. All content is concatenated.

### Add project instructions

```bash # Create or edit project instructions (shared with team) cat > reliant.md << 'EOF' ## Project Guidelines - Use Go 1.22+ features - All PRs require tests - Follow existing naming conventions EOF ```

### Add personal local instructions

```bash # Create or edit local instructions (gitignored, just for you) cat > reliant.local.md << 'EOF' ## My Preferences - I prefer verbose explanations - Always run tests before committing EOF ```

### Add global instructions

```bash # Applies to every project you open cat > ~/.reliant/reliant.md << 'EOF' ## Global Guidelines - Always use meaningful variable names - Write tests for all new features EOF ```

---

## 2. Skills system

Skills are loadable instruction bundles that agents can discover and use on demand.

### Skill structure

``` <skills-root>/<skill-name>/ ├── SKILL.md # Required — frontmatter + instructions ├── references/ # Optional — deep docs, schemas, policies ├── scripts/ # Optional — deterministic routines ├── templates/ # Optional — reusable output artifacts └── assets/ # Optional — images, data files ```

**Naming rules:** Skill name must match its parent directory. Lowercase, letters/digits/hyphens only.

### Required SKILL.md frontmatter

```yaml --- name: my-skill description: What it does and when to use it --- ```

### Recommended frontmatter

```yaml --- name: my-skill description: What it does and when to use it compatibility: reliant metadata: owner: my-team category: tooling --- ```

### Discovery roots (priority order)

Skills are discovered from multiple roots. Higher-priority roots shadow lower ones with the same name.

| Priority | Path | Scope | |----------|------|-------| | 1 (highest) | `<project>/.reliant.local/skills/` | Local | | 2 | `<project>/.reliant/skills/` | Project | | 3 | `<project>/.claude/skills/` | Claude compat | | 4 | `<project>/.codex/skills/` | Codex compat | | 5 | `<project>/.agents/skills/` | Codex agents compat | | 6 | `~/.reliant/skills/` | Global | | 7 | `~/.claude/skills/` | Claude global compat | | 8 | `~/.codex/skills/` | Codex global compat | | 9 (lowest) | Builtin (embedded) | Builtin |

**Only scaffold to Reliant-managed paths** (`.reliant.local/skills/`, `.reliant/skills/`, `~/.reliant/skills/`). Do not create skills in `.claude/`, `.codex/`, or `.agents/` directories.

### Create a project skill

```bash mkdir -p .reliant/skills/my-helper cat > .reliant/skills/my-helper/SKILL.md << 'EOF' --- name: my-helper description: Helps with our custom deployment process compatibility: reliant metadata: owner: platform-team category: devops --- # My Helper

## When to use - When deploying to staging or production

## Steps 1. Run preflight checks 2. Build the artifact 3. Deploy via our CLI EOF ```

### Use a skill

``` skill load <name> # Load a skill by name skill search <query> # Find skills by keyword skill list # List all available skills ```

### Authoring a new skill

When the user wants to create a new skill or improve an existing one, follow this flow.

#### Core principles

1. **Keep SKILL.md concise and high-signal** — put essential workflow/instructions in SKILL.md. Move large details into supporting files (`references/`, `scripts/`, `templates/`, `assets/`). 2. **Write trigger-ready descriptions** — description should clearly state what the skill does and when to use it. Include likely user intents/phrases so activation is reliable. 3. **Prefer deterministic helpers for repeated work** — if the same transformation or command sequence repeats, scaffold a script. 4. **Iterate using concrete tests** — draft realistic prompts, run the skill, inspect outputs, then revise.

#### Step 1: Capture intent

Confirm: - What task/workflow the skill should enable - Typical user prompts that should trigger the skill - Expected output format/quality bar - Required tools, files, APIs, or constraints

#### Step 2: Choose scope and location

Ask whether this should live in: - local (`.reliant.local/skills/...`) - project (`.reliant/skills/...`) - global (`~/.reliant/skills/...`)

#### Step 3: Design structure (progressive disclosure)

Start with `SKILL.md` (required). Optionally add: - `references/` for deep docs/policies/schemas - `scripts/` for deterministic routines - `templates/` or `assets/` for reusable output artifacts

#### Step 4: Author SKILL.md

Required frontmatter: `name`, `description`. Recommended: `compatibility: reliant`, `metadata` (owner/category).

Body should include: - When to use - Inputs needed - Step-by-step procedure - Output expectations - References to supporting files (with when/why to read)

**Starter template:**

```md --- name: <skill-name> description: <what it does + when to use it> compatibility: reliant metadata: owner: <team-or-user> --- # <Skill Title>

## When to use - ...

## Inputs - ...

## Steps 1. ... 2. ...

## Output expectations - ...

## References - See `references/...` when ... ```

#### Step 5: Validate and test

1. Create 2–3 realistic prompts users would actually type. 2. Invoke the skill (`skill load <skill-name>`). 3. Compare output quality against expectations. 4. Refine description/body/supporting files. 5. Re-run prompts and confirm improvement.

### Updating an existing skill

When asked to improve an existing skill:

1. Read current `SKILL.md` and supporting files. 2. Identify likely failure points: weak triggering description, ambiguous steps, missing edge-case guidance, bloated SKILL.md that should be split. 3. Propose targeted edits. 4. Re-test using realistic prompts. 5. Summarize what changed and why.

### Quality checks before finishing

- Path is Reliant-managed and correct scope was used. - Skill name is normalized, stable, and unambiguous. - Description is specific about both capability and triggering context. - Instructions are concise, imperative, and actionable. - Supporting files are referenced only when useful. - At least one invocation test was suggested (or run, if requested).

---

## 3. MCP server configuration

MCP (Model Context Protocol) servers extend agent capabilities with external tools.

### Config file locations

| Priority | Path | |----------|------| | 1 (lowest) | `~/.reliant/mcp.json` | | 2 | `<project>/.reliant/mcp.json` | | 3 (highest) | `<project>/.reliant.local/mcp.json` |

Servers are merged across scopes. Higher-priority scopes override servers with the same name.

### JSON format

```json { "mcpServers": { "server-name": { "command": "npx", "args": ["-y", "@some/mcp-server"], "env": { "API_KEY": "..." }, "type": "stdio", "enabled": true } } } ```

### Server types

| Type | Transport | Config fields | |------|-----------|---------------| | `stdio` (default) | stdin/stdout | `command`, `args`, `env` | | `sse` | Server-Sent Events | `url`, `env` | | `http` | HTTP | `url`, `env` |

### Add an MCP server (stdio)

```bash mkdir -p .reliant cat > .reliant/mcp.json << 'EOF' { "mcpServers": { "my-tool": { "command": "npx", "args": ["-y", "@company/mcp-tool"], "env": { "API_KEY": "sk-..." } } } } EOF ```

### Add an MCP server (SSE/HTTP)

```json { "mcpServers": { "remote-tool": { "type": "sse", "url": "https://mcp.example.com/sse", "env": { "TOKEN": "..." } } } } ```

### Add a language server or anything else that indexes a code tree

A server whose answers come from an INDEXED TREE — a language server, a semantic code-search server — resolves which tree it serves once, when its process starts. Declare `dirScoped` so each project gets its own process:

```json { "mcpServers": { "gopls": { "command": "gopls", "args": ["mcp"], "dirScoped": true } } } ```

Without it, every project shares ONE process, and the second project silently receives answers about the first project's code — confident matches from the wrong repository rather than no matches. Measured with a Go language server registered globally.

`dirScoped` is opt-in because sharing is correct and cheaper for the stateless majority: `github`, `linear`, `sentry` and friends are scoped by a token and an API endpoint, not by a directory, so per-project processes would buy nothing. Dir-scoped servers are started lazily and reaped when idle, so a project you are not working in costs nothing.

### Say what a project must contain before the server is worth starting

A tree indexer pays its whole cost — the walk, the open files, the resident index — before it can discover it has nothing to do. Add `requiresFiles` so it is never started where it has nothing to index:

```json { "mcpServers": { "gopls": { "command": "gopls", "args": ["mcp"], "dirScoped": true, "requiresFiles": ["go.mod", "go.work"] } } } ```

Without it, opening a Unity/C# project with zero `.go` files still started a Go language server, which indexed a 9.9 GB checkout and reached 28,467 open file descriptors and 1.9 GB resident. One per project, and seventeen projects exhaust macOS's system-wide file table — for every process on the machine.

- Entries are globs and ANY match satisfies the server, so a server covering several ecosystems lists the marker of each (`["*.csproj", "*.sln"]`). - A pattern with no `/` matches by base name at any depth, so `go.mod` also covers a monorepo's `services/api/go.mod`. A pattern containing `/` is matched against the project-relative path (`services/*/go.mod`). - Omit it and there is no precondition: the server starts for every project, exactly as before. - The check is a bounded, gitignore-aware scan, not a full walk. In a very large tree the scan can hit its bound before reaching a deeply-buried marker, and the server is then not started; keep the marker near the root, or declare nothing.

Reliant also caps how many per-project processes all dir-scoped servers hold at once. Past the cap the least recently used one is reaped and respawns on its next tool call, so visiting many projects is fine — running an unbounded number of indexers at once is not.

Two ways to tell a server WHICH tree, depending on how it expects to be told:

```json { "mcpServers": { "reads-its-cwd": { "command": "gopls", "args": ["mcp"], "dirScoped": true }, "takes-a-flag": { "command": "some-lsp-bridge", "args": ["--workspace", "${projectPath}"], "dirScoped": true }, "pinned-to-one-tree": { "command": "gopls", "args": ["mcp"], "dir": "$HOME/src/monorepo" } } } ```

- The process starts in `dir` when set, otherwise in the project the tool call belongs to. `$VAR` / `${VAR}` are expanded. - `${projectPath}` in `args` is replaced with that same project path, for servers that take the tree as an argument instead of reading their working directory. - An explicit `dir` PINS the server to one tree regardless of the caller, which is the only reason to set it.

### Disable a server without removing it

```json { "mcpServers": { "noisy-server": { "enabled": false } } } ```

### Keep secrets local

Put API keys in `.reliant.local/mcp.json` (gitignored) rather than `.reliant/mcp.json`:

```bash # .reliant/mcp.json — committed, no secrets { "mcpServers": { "my-tool": { "command": "npx", "args": ["-y", "@company/mcp-tool"] } } }

# .reliant.local/mcp.json — gitignored, has secrets { "mcpServers": { "my-tool": { "env": { "API_KEY": "sk-secret-key" } } } } ```

Or keep the secret out of every file and reference your environment instead. `${VAR}`, `${VAR:-default}` and `$VAR` work in `command`, `args`, `url`, `headers`, `dir` and `env` values. The config is stored and shown exactly as written; the reference is resolved on your machine, from the environment the Reliant daemon runs in, when the server starts. A reference resolves against the server's own `env` block first:

```json { "mcpServers": { "github": { "type": "http", "url": "https://api.githubcopilot.com/mcp/", "headers": { "Authorization": "Bearer ${GITHUB_TOKEN}" } } } } ```

---

## 4. Presets

Presets are YAML files that bundle spawn parameters for reusable agent configurations.

### Preset locations

| Priority | Location | Source | |----------|----------|--------| | 1 (lowest) | Builtin (embedded) | `builtin` | | 2 | `<project>/.reliant/presets/*.yaml` and each nested repo's `<repo>/.reliant/presets/*.yaml` (a root preset wins its bare name; `<repo>/<name>` names one repo's) | `project` | | 3 (highest) | User presets (database) | `user` |

Project presets with the same name as a builtin will override the builtin.

### Preset format

```yaml name: careful-reviewer description: Slow, methodical code review with high scrutiny tag: agent params: permission: readonly model: tags: [flagship] system_prompt: | You are a meticulous code reviewer. Check for: - Security vulnerabilities - Performance issues - Code style consistency tools: - tag:coding:default spawn_presets: - researcher temperature: 0.2 thinking_level: high ```

### Key preset fields

| Field | Description | |-------|-------------| | `name` | Preset identifier (matches filename without `.yaml`) | | `description` | Shown in the preset picker UI | | `tag` | Must match the workflow/group tag (usually `agent`) | | `params.permission` | `readonly`, `mutating`, or `orchestrator` | | `params.model` | Use `tags: [flagship]`, `tags: [moderate]`, etc. Never hardcode model names. | | `params.system_prompt` | System instructions for the spawned agent | | `params.tools` | Tool access: `tag:coding:default`, `tag:mcp`, etc. | | `params.spawn_presets` | Which presets this agent can use to spawn sub-agents | | `params.temperature` | Sampling temperature (0.0–1.0) | | `params.thinking_level` | `high`, `medium`, `low` |

### Create a project preset

```bash mkdir -p .reliant/presets cat > .reliant/presets/my-preset.yaml << 'EOF' name: my-preset description: Custom agent for our specific workflow tag: agent params: permission: mutating model: tags: [flagship] system_prompt: | You specialize in our internal API patterns. tools: - tag:coding:default spawn_presets: - researcher - general EOF ```

---

## 5. Config YAML

General Reliant settings via YAML config files.

### Config file locations

| Priority | Path | |----------|------| | 1 (lowest) | `~/.reliant/config.yaml` | | 2 | `<project>/.reliant/config.yaml` | | 3 (highest) | `<project>/.reliant.local/config.yaml` |

Settings are merged across scopes with higher priority winning.

---

## 6. Project structure summary

``` <project>/ ├── reliant.md # Project memory (committed) ├── reliant.local.md # Local memory (gitignored) ├── .reliant/ │ ├── config.yaml # Project config │ ├── mcp.json # Project MCP servers │ ├── skills/ │ │ └── <skill-name>/ │ │ └── SKILL.md # Project skill │ └── presets/ │ └── <preset-name>.yaml # Project preset ├── .reliant.local/ │ ├── config.yaml # Local config (gitignored) │ ├── mcp.json # Local MCP servers (gitignored) │ └── skills/ │ └── <skill-name>/ │ └── SKILL.md # Local skill (gitignored) ~/.reliant/ ├── reliant.md # Global memory ├── config.yaml # Global config ├── mcp.json # Global MCP servers └── skills/ └── <skill-name>/ └── SKILL.md # Global skill ```

## Quick reference: "Where do I put...?"

| I want to... | File | |---------------|------| | Add team-wide coding rules | `reliant.md` | | Add personal preferences | `reliant.local.md` | | Add rules for all projects | `~/.reliant/reliant.md` | | Share an MCP tool with the team | `.reliant/mcp.json` | | Add an MCP tool with secret keys | `.reliant.local/mcp.json` | | Create a reusable agent preset | `.reliant/presets/<name>.yaml` | | Add a project skill | `.reliant/skills/<name>/SKILL.md` | | Add a personal skill | `.reliant.local/skills/<name>/SKILL.md` | | Add a skill for all projects | `~/.reliant/skills/<name>/SKILL.md` |

Intended uses

  • When deploying to staging or production
  • ...

Implementation notes

  • Review the source instructions and adapt inputs before running the workflow.

Try it, then tell us how it went

A copied prompt does not tell us whether the task worked. Report your result after checking the output. We collect your tool and outcome, never your files or prompt.