Workflows Overview

Everything in Reliant runs through workflows. When you type a message and press enter, you’re triggering a workflow. When an agent reads your codebase, executes tools, and responds with a solution, that’s a workflow running. Understanding workflows is understanding how Reliant works at its core.

A workflow is a programmable sequence of AI operations. It defines what an agent can do—which tools it has access to, how it handles approval, when it should loop back for more work, and when it’s done. Workflows transform simple chat into intelligent, iterative problem-solving.

The Agent Workflow

The default experience in Reliant—the one you use every time you chat—is itself a workflow called builtin://agent. This isn’t a special case or simplified mode; it’s a full workflow that happens to be the one most users need most of the time.

Here’s what happens when you send a message:

┌─────────────────────────────────────────────────────────────────┐
│                        Agent Workflow                            │
│                                                                  │
│   ┌──────────┐      ┌──────────────┐      ┌─────────────────┐   │
│   │  Your    │      │   Call LLM   │      │  Execute Tools  │   │
│   │ Message  │ ───► │  (Claude,    │ ───► │  (read, edit,   │ ──┼──┐
│   │          │      │   GPT, etc)  │      │   search, etc)  │   │  │
│   └──────────┘      └──────────────┘      └─────────────────┘   │  │
│                              ▲                                   │  │
│                              │         Loop until done           │  │
│                              └───────────────────────────────────┼──┘
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

The workflow sends your message to the LLM. The LLM responds, possibly requesting tool calls—reading files, searching code, making edits. The workflow executes those tools and sends the results back to the LLM. This loop continues until the LLM responds without requesting more tools, indicating the task is complete.

This simple loop is remarkably powerful. A single message like “add input validation to the signup form” might trigger dozens of iterations: the agent reads your codebase to understand its patterns, identifies the relevant files, plans the changes, implements them, and verifies they work—all within this same loop structure.

Execution Modes

The agent workflow supports three modes that control how tool execution works. You select the mode in the chat interface before sending a message.

Agent mode (the default) auto-approves all tool calls. The agent works autonomously, reading files, making edits, and running commands without waiting for your approval at each step. This is the most efficient mode for tasks you trust the agent to complete independently.

Manual mode requires your approval before each tool execution. When the agent wants to read a file or make a change, you see exactly what it’s requesting and can approve or deny. This mode is useful when you want to understand what the agent is doing step by step, or when working with sensitive code that requires careful review.

Plan mode restricts the agent to read-only tools. It can explore your codebase, search for patterns, and analyze code, but it cannot make any modifications. Instead of implementing changes, the agent creates a structured plan with tasks that you or another agent can execute later. Plan mode is ideal for understanding complex problems before committing to a solution.

Running Workflows

Workflows appear in the workflow selector in the chat interface. The default agent workflow is pre-selected, but you can choose others—including custom workflows you’ve created or advanced built-in workflows for specific patterns like TDD or code review.

When you select a workflow, a parameters panel appears showing the configurable options. For the agent workflow, this includes:

Parameter	Purpose
`mode`	Execution mode (agent, manual, or plan)
`model`	Which LLM to use (Claude, GPT, etc.)
`temperature`	Response randomness (0 = focused, 1 = creative)
`thinking_level`	Extended thinking depth (low, medium, high)
`tools`	Which tools the agent can access
`spawn_presets`	Which presets are available for spawning sub-agents

You can adjust these parameters before each conversation, tailoring the agent’s behavior to your current task. A complex refactoring might warrant a higher thinking level and lower temperature, while brainstorming might benefit from higher temperature and more creative responses.

Understanding Presets

Manually configuring parameters for every conversation would be tedious. Presets solve this by bundling parameter values into reusable configurations that you can select with a single click.

A preset is a saved configuration that pre-fills workflow parameters. When you select the “researcher” preset, for example, it configures the agent workflow with a specialized system prompt for research tasks, a lower temperature for focused analysis, and a curated set of read-oriented tools. You get a research-optimized agent without touching individual parameters.

Tag-Based Matching

Presets use tags to determine which workflows they’re compatible with. The agent workflow has the tag agent, so presets with tag: agent appear when you’re using it. This means a single preset can work with any workflow that shares the same tag—as long as the parameters exist in the target workflow, the preset can set them.

Built-in Presets

Reliant includes several presets designed for common development tasks:

general provides a balanced configuration for everyday coding tasks. It uses comprehensive tooling and a system prompt emphasizing discovery-first problem solving. This is what most developers use most of the time.

researcher configures the agent as a research specialist focused on understanding rather than implementing. It uses a detailed system prompt for systematic investigation, lower temperature for focused analysis, and emphasizes read-only tools. Use this when you need to understand a codebase, evaluate approaches, or gather information before implementing.

code_reviewer transforms the agent into a code review specialist. It provides structured feedback on quality, security, and maintainability, with a system prompt that emphasizes constructive criticism and actionable recommendations. The tools are read-oriented since reviewers analyze rather than modify.

documentation configures the agent for creating technical documentation. It includes a comprehensive system prompt on documentation best practices—teaching versus reference content, when to use prose versus lists, and how to write effective explanations. This preset powers much of Reliant’s own documentation.

refactor specializes the agent for code refactoring tasks. It emphasizes behavior preservation, systematic approaches, and mastery of tools like find_replace and move_code that make large-scale changes manageable.

debug_with_me creates a collaborative debugging partner that works iteratively with you. It maximizes automation but knows when to ask for help, providing clear handoff points when it needs you to run commands, check output, or make decisions.

Custom Presets

Beyond the built-in presets, you can create your own in .reliant/presets/. A custom preset is a YAML file that specifies parameter values:

name: careful
description: Methodical approach with manual approval
tag: agent
params:
  mode: manual
  temperature: 0.3
  thinking_level: high
  model: claude-4-opus

Project presets override built-in presets with the same name, so teams can standardize configurations across their codebase. For comprehensive coverage of custom presets, see the Presets guide.

Workflow Outputs

Workflows produce outputs that become available when the workflow completes. For the agent workflow, the primary outputs are:

message: The final assistant message from the conversation
response_text: The text content of that message
iterations: How many times the agent loop ran
succeeded: Whether the workflow completed successfully

These outputs matter most when workflows are composed—when a parent workflow spawns child workflows and needs their results. The agent workflow’s thread also contains the complete conversation history, which persists in your session for later reference or continuation.

Beyond the Agent Workflow

While the agent workflow handles most tasks, Reliant includes additional workflows for specialized patterns:

plan-debate uses two agents—a proposer and a critic—to refine plans through adversarial collaboration. The proposer suggests approaches while the critic identifies weaknesses, iterating until they reach consensus.

parallel-compete runs three agents simultaneously on the same problem, then uses a reviewer to pick the best solution. This is powerful for problems where multiple valid approaches exist.

tdd-loop implements test-driven development as a workflow: write failing tests, implement until they pass, refactor, repeat.

These advanced workflows demonstrate what’s possible with workflow composition. For details on these patterns and how to build your own, see the Multi-Agent Patterns guide.