Presets

Presets are saved configurations of workflow parameters that make it easy to switch between different agent behaviors. Instead of manually configuring model, temperature, tools, and system prompts each time you run a workflow, you select a preset that bundles all these settings together.

Think of presets as profiles for your agents. A researcher preset configures an agent for thorough investigation with low temperature for accuracy. A code reviewer preset configures an agent to focus on quality feedback with access to search tools. When you select a preset, all its parameters apply at once, giving you a fully configured agent ready for its specific role.

How Presets Work

Presets use tag-based matching to connect with workflows. Every preset declares a tag that specifies what kind of workflow inputs it targets. When you load presets for a workflow, Reliant matches the preset’s tag against the workflow’s tag (or a group’s tag for multi-agent workflows). Only presets with matching tags appear as options.

This matching system enables powerful flexibility. A preset with tag: agent works with any workflow that has tag: agent on its inputs or groups. The same researcher preset can configure a standalone agent workflow, or configure just the research phase of a multi-phase workflow—the tag matching handles it automatically.

Presets can be partial. A preset doesn’t need to specify every parameter the workflow accepts. It might only set model and temperature, leaving other parameters to their defaults or to be configured inline. This allows presets to focus on the settings that matter for their particular use case without being overly prescriptive about everything else.

When multiple presets match different groups in a workflow, each group gets its own preset selection. A multi-agent workflow might have one group configured with the researcher preset and another with the code reviewer preset, each bringing their specialized configuration to their respective agent.

Built-in Presets

Reliant includes several built-in presets for common agent roles. These are immediately available without any configuration.

general

The general preset provides a balanced configuration suitable for most coding tasks.

Parameter	Value
model	claude-4.5-opus
temperature	1.0
tools	tag:default, tag:mcp

The general preset configures an agent as a versatile coding assistant with a discovery-first approach. It emphasizes understanding before acting, prioritizing quality over speed, and systematic problem solving. This is the default choice when you don’t need specialized behavior—good for feature implementation, bug fixes, and general development work.

researcher

The researcher preset configures an agent for comprehensive codebase investigation and analysis.

Parameter	Value
model	claude-4.5-opus
temperature	0.3
tools	tag:search, tag:web, view, bash, create_plan, tag:mcp

The lower temperature produces focused, deterministic output ideal for systematic investigation. The researcher agent follows a methodical investigation process: planning and scope definition, architecture and codebase analysis, pattern recognition and conventions analysis, then historical analysis. It excels at understanding complex systems before any implementation begins, mapping dependencies, identifying patterns, and documenting findings that inform subsequent work.

Use the researcher preset when you need to understand a codebase before making changes, analyze how a feature is currently implemented, map dependencies between components, or investigate why something works the way it does.

code_reviewer

The code reviewer preset configures an agent for comprehensive code quality feedback.

Parameter	Value
model	claude-4-sonnet
temperature	0.7
tools	tag:search, tag:web, view, bash

The code reviewer focuses on evaluating changes for quality, correctness, security, and maintainability. It categorizes issues by severity (critical, major, minor) and provides constructive, specific, educational feedback. Reviews cover functional correctness, code quality assessment, and security and performance analysis.

The preset uses read-only tools since code reviewers observe and comment rather than modify. Use this preset for pull request reviews, design evaluations, or any situation where you need systematic quality feedback.

documentation

The documentation preset configures an agent for creating comprehensive technical documentation.

Parameter	Value
model	claude-4-sonnet
temperature	0.7
tools	view, write, edit, grep, glob, bash, fetch

The documentation agent focuses on teaching through clear explanation and realistic examples, helping readers build mental models rather than just listing facts. It distinguishes between teaching content (prose explanations) and reference content (tables, lists for scanning), using each format appropriately.

The preset emphasizes investigation before writing—understanding the code thoroughly before documenting it—and testing every example to ensure accuracy.

refactor

The refactor preset configures an agent for systematic code improvements while preserving behavior.

Parameter	Value
model	claude-4-sonnet
temperature	0.7
tools	find_replace, move_code, edit, patch, grep, glob, view, bash

The refactor agent follows a strict methodology: assess and plan, verify tests pass before changes, execute incremental transformations, then verify behavior preservation. It’s configured with specialized tools for code transformation—find_replace for renaming across files, move_code for relocating functions, and patch for coordinated multi-file changes.

Use the refactor preset when reorganizing code structure, renaming identifiers across a codebase, extracting functions or classes, or cleaning up technical debt. The agent always runs tests before and after changes to ensure nothing breaks.

debug_with_me

The debug_with_me preset configures a collaborative debugging agent that works interactively with users.

Parameter	Value
model	claude-4-sonnet
temperature	0.2
tools	fetch, glob, grep, view, write, edit, patch, bash, get_plan, list_tasks, update_task

The very low temperature produces consistent, methodical debugging behavior. This agent maximizes automation—exhausting all programmatic investigation approaches before requesting user assistance. When it does need user help, it provides clear handoffs with specific, simple tasks.

The debugging methodology runs in phases: automated investigation (logs, configurations, code analysis), user collaboration only when necessary (visual confirmation, environment-specific information, manual testing), then solution implementation with verification loops. Use this preset when you want hands-on collaboration with an agent to diagnose and fix issues.

ux

The UX preset configures an agent for user interface design and implementation.

Parameter	Value
model	claude-4-sonnet
temperature	0.7
tools	fetch, glob, grep, view, write, edit, patch, bash, layout_library

The UX agent researches current design trends before implementing, supports multiple style modes (minimalist, experimental, professional, glass/3D, retro, organic), and emphasizes accessibility standards (WCAG 2.1 AA compliance) and performance (Core Web Vitals). It generates React/Tailwind components with proper semantic HTML and responsive design.

env_setup

The env_setup preset configures an agent to document development environments and create debugging tools.

Parameter	Value
model	claude-4-sonnet
temperature	0.7
tools	bash, view, write, edit, patch, glob, grep, websearch

This agent explores a codebase and documents how to work with it: how to start the development environment, configuration landscape, database locations and queries, log locations, and port discovery. It also creates practical debugging scripts in .reliant/tools/ that provide observability into the running system.

project_scanner

The project_scanner preset configures an agent for comprehensive codebase analysis.

Parameter	Value
model	claude-4-sonnet
temperature	0.7
tools	fetch, glob, grep, view, bash, metadata_writer, project_analyzer

This agent transforms unknown codebases into well-documented project metadata. It analyzes project structure, discovers components and dependencies, recognizes development patterns, and generates structured metadata that enables other agents to work effectively with the project.

Creating Custom Presets

Custom presets live in .reliant/presets/ in your project directory. Each preset is a YAML file that specifies a name, description, tag, and parameters.

Here’s a complete example of a custom preset:

name: careful-reviewer
description: Conservative code review with strict quality standards
tag: agent
params:
  model: claude-4.5-opus
  temperature: 0.2
  tools:
    - tag:search
    - view
    - bash
  system_prompt: |
    You are a meticulous code reviewer with extremely high standards.
    
    Review every change with these priorities:
    1. Security vulnerabilities - treat any potential issue as critical
    2. Data integrity - ensure no data loss or corruption is possible
    3. Error handling - verify all failure modes are handled gracefully
    4. Test coverage - require tests for any new or modified code paths
    
    Be conservative. When in doubt, request clarification rather than
    approving code that might have issues.
    
    For each issue found, explain:
    - What the problem is
    - Why it matters
    - How to fix it

This preset configures a more conservative code reviewer than the built-in version—lower temperature for consistency, a more capable model for deeper analysis, and a stricter system prompt that emphasizes security and data integrity.

Preset Structure

Every preset follows this structure:

name: preset-name           # Required: identifier for the preset
description: What it does   # Optional: shown in preset picker
tag: agent                  # Required: matches workflow/group tags
params:                     # Required: parameter values to apply
  model: claude-4-sonnet
  temperature: 0.7
  tools:
    - tool-name
    - tag:tool-group
  system_prompt: |
    Instructions for the agent...

The tag field is crucial—it determines which workflows and groups this preset can configure. Most presets use tag: agent to match the standard agent workflow inputs.

Configurable Parameters

Presets can configure any parameter that the matched workflow accepts. Common parameters include:

model: The Claude model to use. Options include claude-4.5-opus, claude-4-sonnet, and other available models. More capable models handle complex reasoning better but cost more.

temperature: Controls response randomness from 0.0 to 1.0. Lower values (0.1-0.3) produce focused, deterministic output suitable for research, debugging, and systematic tasks. Higher values (0.7-1.0) increase creativity and variation, useful for brainstorming and creative writing.

system_prompt: Instructions that define the agent’s role, approach, and constraints. This is where you customize agent behavior most significantly—what it should prioritize, how it should approach problems, what patterns to follow.

tools: List of tools the agent can access. Specify individual tools by name (view, edit, bash) or tool groups by tag (tag:search, tag:default, tag:mcp). Limiting tools focuses the agent on specific capabilities.

compaction_threshold: Token count that triggers conversation compaction for long-running sessions.

max_turns: Maximum number of conversation turns before the agent stops.

Tool Specification

Tools can be specified in several ways:

params:
  tools:
    # Individual tools by name
    - view
    - edit
    - bash
    
    # Tool groups by tag
    - tag:default    # Standard editing and file tools
    - tag:search     # grep, glob for code exploration
    - tag:web        # fetch for web requests
    - tag:mcp        # All configured MCP tools

Using tags lets you reference logical groups of tools without listing each one. The tag:default includes the core tools most agents need, while tag:mcp includes any MCP servers you’ve configured.

Config-as-Code

Presets in .reliant/presets/ are regular files that can be checked into version control. This enables several powerful workflows:

Team standardization: Share agent configurations across your team. Everyone uses the same carefully tuned presets, ensuring consistent behavior and quality standards.

Project-specific customization: Different projects have different needs. A security-focused project might have stricter code review presets. A documentation project might have presets optimized for technical writing.

Iterative improvement: As you learn what works, refine your presets and commit the improvements. Your agent configurations evolve alongside your codebase.

Override built-ins: Project presets with the same name as built-in presets take precedence. Create a general.yaml in your project to customize the general preset for your specific needs without changing Reliant itself.

Preset Loading Order

Reliant loads presets in this order:

Built-in presets (embedded in Reliant)
Project presets (from .reliant/presets/)

Project presets override built-in presets with the same name. This means you can customize any built-in preset by creating a file with the same name in your project’s preset directory.

Examples

Specialized Debugging Preset

For complex debugging sessions where you need maximum context and careful analysis:

name: deep-debug
description: Thorough debugging with extensive context gathering
tag: agent
params:
  model: claude-4.5-opus
  temperature: 0.1
  tools:
    - tag:default
    - tag:search
    - tag:mcp
  system_prompt: |
    You are debugging a complex issue. Before attempting any fix:
    
    1. Gather comprehensive context
       - Read all relevant source files completely
       - Trace the execution path that triggers the bug
       - Identify all components involved
       
    2. Form and test hypotheses
       - List possible causes
       - Design tests to confirm or rule out each hypothesis
       - Document your reasoning
       
    3. Implement the minimal fix
       - Change only what's necessary
       - Preserve existing behavior except for the bug
       - Add a test that would have caught this bug
    
    Never guess. Always verify with actual code and tests.

Fast Implementation Preset

For straightforward tasks where speed matters more than exhaustive verification:

name: quick-impl
description: Fast implementation for simple, well-understood tasks
tag: agent
params:
  model: claude-4-sonnet
  temperature: 0.7
  tools:
    - tag:default
  system_prompt: |
    Implement the requested feature efficiently.
    
    Focus on:
    - Clear, idiomatic code
    - Following existing patterns in the codebase
    - Basic error handling
    
    Move quickly but don't sacrifice code quality.

Security Audit Preset

For security-focused code review:

name: security-audit
description: Security-focused code analysis
tag: agent
params:
  model: claude-4.5-opus
  temperature: 0.2
  tools:
    - tag:search
    - view
    - bash
  system_prompt: |
    You are a security auditor reviewing code for vulnerabilities.
    
    Check systematically for:
    - Injection vulnerabilities (SQL, command, XSS)
    - Authentication and authorization issues
    - Sensitive data exposure
    - Insecure dependencies
    - Cryptographic weaknesses
    - Input validation gaps
    
    For each finding, provide:
    - Severity (Critical/High/Medium/Low)
    - Location (file and line numbers)
    - Description of the vulnerability
    - Proof of concept if applicable
    - Recommended remediation
    
    Be thorough. Security issues that slip through can have serious consequences.

Managing Presets in the UI

While presets can be created as YAML files, Reliant also provides UI-based management for viewing, editing, and setting defaults.

Viewing Presets

Open the Workflows page from the sidebar and click the Presets tab. This shows all available presets organized into two sections:

Your Presets - Custom presets you’ve created (either as project files or saved from chat)
Built-in Presets - System presets that come with Reliant

Each preset card displays the preset name, description, source badge (Built-in, Project, or Custom), and the tag it targets.

Editing Presets

Hover over any non-built-in preset to reveal the edit and delete buttons. Click the pencil icon to open the edit modal where you can modify:

Name - The preset’s display name
Description - A brief explanation of what the preset is for

For project presets (stored as YAML files in .reliant/presets/), editing updates the file directly. Changes take effect immediately.

Built-in presets cannot be edited. To customize a built-in preset, create a project preset with the same name—it will override the built-in version.

Deleting Presets

Click the trash icon on any custom preset to delete it. For project presets, this removes the YAML file from .reliant/presets/. Deletion cannot be undone.

Setting Default Presets

Default presets automatically apply when you start a new chat with a workflow. This saves time by pre-configuring your preferred settings.

To set a default preset for a workflow:

Go to the Workflows tab
Hover over a workflow with a preset badge (e.g., “Preset: general”)
Click the gear icon to open preset configuration
Select your preferred preset from the dropdown
Click Save

The next time you start a chat with this workflow, your default preset will be automatically selected.

Creating Presets from Chat

The easiest way to create a new preset is to save your current chat configuration.

Saving Current Settings as a Preset

Start a new chat or open an existing one
Configure your workflow parameters (model, temperature, tools, system prompt, etc.)
Click the Save as Preset button in the parameters panel
Enter a name and description for your preset
Click Save

The preset is saved to your project’s .reliant/presets/ directory and immediately becomes available for selection.

What Gets Saved

When you save a preset from chat, it captures:

Model - The selected LLM
Temperature - The creativity/determinism setting
Tools - The enabled tools and MCP servers
System Prompt - Any custom instructions
Tag - Inherited from the current workflow/group

The preset only saves parameters you’ve explicitly configured. Default values are not included, allowing the preset to work across different workflows that share the same tag.

Best Practices for Preset Creation

Name presets descriptively. Use names that indicate the preset’s purpose: fast-prototyping, careful-refactor, security-audit. Avoid generic names like my-preset or test.

Write useful descriptions. The description appears in preset selectors. Include what makes this preset different: “Lower temperature for deterministic debugging” or “Opus model for complex architectural decisions.”

Start from built-in presets. If a built-in preset is close to what you need, select it first, make adjustments, then save as a new preset. This ensures you’re building on tested configurations.

Use specific tags. Presets with tag: agent work broadly across many workflows. For presets designed for specific use cases, consider whether a more specific tag would be appropriate.