Tools Reference

Tools Reference

Tools enable AI agents to interact with your codebase, filesystem, and external services. When a workflow runs, the AI can invoke tools to read files, make changes, run commands, search the web, and more.

Reliant provides a curated set of built-in tools designed for software development tasks, plus automatic integration with any MCP servers you configure.

Tool Tags

Every tool has one or more tags that categorize its functionality. Tags enable flexible tool filtering in workflows—you can include entire categories of tools rather than listing each one individually.

Tag Memberships

Here’s which tags each built-in tool belongs to:

Tool Filtering

Workflows use the tool_filter input to control which tools are available. The filter syntax supports tags, individual tool names, glob patterns, and exclusions.

Filter Syntax

Filter Examples

Standard development tools:

tool_filter:
  - tag:default

Read-only mode (safe for planning):

tool_filter:
  - tag:readonly

Default tools without bash execution:

tool_filter:
  - tag:default
  - "!bash"

Only search tools:

tool_filter:
  - tag:search

Combine multiple tags:

tool_filter:
  - tag:readonly
  - tag:mcp

Specific tools only:

tool_filter:
  - view
  - grep
  - glob

Include MCP tools by pattern:

tool_filter:
  - tag:default
  - mcp_github_*

Full control with spawn configuration:

tool_filter:
  - tag:default
  - "!bash"
  - spawn:builtin://agent(general,researcher)

Evaluation Order

1. Inclusions first: All tag:X and plain tool names are collected
2. Exclusions second: Any !name entries remove tools from the set
3. Globs expand: Patterns like mcp_* match against all available tools
4. Spawn parsed: spawn: entries configure sub-agent capabilities

File Tools

Tools for reading, writing, and modifying files in your codebase.

view

Read and display file contents with line numbers.

Features:

• Displays line numbers for easy reference
• Automatic truncation of very long lines (>500 chars)
• Suggests similar filenames when file not found
• Maximum output size of 16KB (~4K tokens)

Example:

{
  "file_path": "/path/to/file.go",
  "offset": 100,
  "limit": 50
}

write

Create or completely overwrite a file.

Features:

• Creates parent directories automatically
• Checks for external modifications before writing
• Skips write if content is unchanged
• Shows diff of changes made

When to use:

• Creating new files
• Complete file rewrites
• Generating configuration files

edit

Make precise text replacements in files. Supports single or multiple edits in one operation.

Edit Operation:

Features:

• Atomic operation: all edits succeed or all fail
• Supports creating new files (empty old_string)
• Supports deleting content (empty new_string)
• Shows diff of changes

Example:

{
  "edits": [
    {
      "file_path": "/path/to/file.go",
      "old_string": "func oldName(",
      "new_string": "func newName(",
      "replace_all": true
    }
  ]
}

Best practices:

• Always view files first to understand context
• Include 3-5 lines of context in old_string for uniqueness
• Whitespace and indentation must match exactly

patch

Apply coordinated changes across multiple files using a patch format.

Patch Format:

*** Begin Patch
*** Update File: /path/to/file
@@ Context line (unique within file)
 Line to keep
-Line to remove
+Line to add
 Line to keep
*** Add File: /path/to/new/file
+Content of new file
*** Delete File: /path/to/delete
*** End Patch

Features:

• Atomic: all changes apply or none
• Supports update, add, and delete operations
• Context lines ensure precise placement

find_replace

Perform find-and-replace across multiple files matching a pattern.

Features:

• Glob pattern file filtering
• Regex support with capture groups ($1, $2, etc.)
• Shows summary of all changes made

Example:

{
  "find_pattern": "import (.*) from 'old-module'",
  "replace_text": "import $1 from 'new-module'",
  "use_regex": true,
  "file_glob": "**/*.ts"
}

move_code

Move or copy blocks of code between locations in the same file or across files.

Example:

{
  "source_file": "/path/to/file.go",
  "source_start": 50,
  "source_end": 75,
  "target_file": "/path/to/other.go",
  "target_line": 100,
  "operation": "move"
}

Search Tools

Tools for finding files and searching content.

grep

Search file contents using ripgrep. The primary tool for code search.

Output Modes:

• files_with_matches: File paths sorted by modification time
• content: Matching lines with line numbers
• count: Match counts per file

Example:

{
  "pattern": "func.*Error",
  "type": "go",
  "output_mode": "content",
  "-C": 3
}

glob

Find files by name pattern.

Example:

{
  "pattern": "**/*_test.go",
  "head_limit": 50
}

Execution Tools

Tools for running shell commands. On Unix/macOS, these use Bash. On Windows, PowerShell is used instead.

bash

Execute shell commands in a stateless environment.

Important behaviors:

• Each command runs in a fresh shell—no state persists
• Working directory is set to the project/worktree root
• Use && or ; to chain commands
• Background processes return a process ID

Example:

{
  "command": "npm test -- --coverage",
  "timeout": 300000
}

Background process:

{
  "command": "npm run dev",
  "run_in_background": true
}

bash_list

List background processes.

bash_output

Get output from a background process with pagination and filtering.

bash_kill

Terminate a background process.

Web Tools

Tools for accessing external web resources.

fetch

Download content from a URL.

Example:

{
  "url": "https://api.example.com/docs",
  "format": "markdown"
}

websearch

Search the web using DuckDuckGo.

Search tips:

• Use site:github.com for domain-specific searches
• Use quotes for exact phrases
• Use -term to exclude terms

Example:

{
  "query": "golang context timeout example",
  "count": 5
}

Planning Tools

Tools for creating and managing execution plans with tasks.

create_plan

Create a new plan with tasks for the current session.

Task structure:

{
  "title": "Implement user authentication",
  "description": "Add login and registration endpoints"
}

update_plan

Modify an existing plan.

get_plan

Retrieve the current session’s plan.

No parameters required.

list_tasks

List all tasks in the current plan.

No parameters required.

add_task

Add a new task to the plan.

Metadata options:

• preferred_agent: Which agent type should handle this
• tool_hints: Suggested tools (use_bash, search_first)
• dependencies: What this task depends on
• notes: Context or discoveries
• priority: high, medium, low

update_task

Update a task’s status or details.

Status values:

• pending - Not started
• in_progress - Currently working
• completed - Successfully finished
• failed - Could not complete
• blocked - Waiting on something
• skipped - Decided not to do
• cancelled - No longer needed

create_subtask

Create a subtask under an existing task.

Analysis Tools

Tools for analyzing project structure and codebase.

project_analyzer

Analyze project structure, languages, and build systems.

Actions:

• detect_type - Identify project type (single app, monorepo, etc.)
• find_build_files - Locate build configuration files
• detect_languages - Identify programming languages used
• find_tests - Find test file patterns

Git Tools

worktree

Manage git worktrees for parallel development.

Create example:

{
  "action": "create",
  "name": "feature-auth",
  "base_branch": "main",
  "copy_files": [".env", ".env.local"]
}

MCP Tools

Tools from MCP servers are automatically available and tagged with tag:mcp.

Naming Convention

MCP tools are prefixed with mcp_ followed by the server name:

• mcp_github_create_issue
• mcp_slack_send_message
• mcp_postgres_query

Filtering MCP Tools

Include all MCP tools:

tool_filter:
  - tag:mcp

Include specific server’s tools:

tool_filter:
  - mcp_github_*

Combine with built-in tools:

tool_filter:
  - tag:default
  - tag:mcp

Configuration

MCP servers are configured in Reliant’s settings. See MCP Servers for setup instructions.