Custom Modes in Cline: Defining Specialized Agent Personas

Point an autonomous coding agent at a multi-repository workspace without operational boundaries, and it will begin refactoring core libraries before identifying how tests are run. The agent treats exploration and execution as a single continuous loop, attempting to fix perceived syntax issues or restructure directories while it is supposed to be inspecting dependencies. When an agent possesses unrestricted write access during discovery, a developer asking a basic architectural question risks having working code silently rewritten across dozens of files.

Custom modes in coding agents allow developers to define specialized operational personas with constrained tool access, dedicated system prompts, and scoped permissions for tasks like architecture design, code review, or Q&A.

In complex software systems, the cognitive demands of high-level system design conflict with line-level code generation. An architectural assessment requires broad repository indexing, dependency mapping, design pattern validation, and macro-level reasoning. Granting write access during that phase creates immediate operational hazards. An unconstrained model may attempt to resolve an ambiguous requirement by modifying production configuration files, introducing unvetted third-party packages, or breaking API contracts before a human engineer reviews the approach.

Developers managing complex codebases consistently favor read-only architect modes during initial task evaluation, ensuring the agent understands repository relationships before granting authorization for automated edits. Scoping tool access to read operations during discovery prevents unintended file modifications, suppresses hallucinated refactors, and protects established project conventions.

• Claude Code Subagents: How to Create and Use Specialized AI AgentsMost AI coding sessions degrade after an hour because file reads, search results, and test output flood the context...
• How to Build Custom Agents in OpenClawOpenClaw hit 3.2 million monthly active users in April 2026, yet most deployments still run a single default agent...
• Best Cline Alternatives for AI Coding AgentsCline reports 8.0M+ installs and a free open-source product for individuals, so cost alone rarely drives a switch....
• How to Set Up MCP Servers in Cline: Configuration and Remote SetupsWhile most developers configure Model Context Protocol (MCP) servers locally, local setups restrict AI agents to a...
• Cline vs Cursor: Comparing the Top AI Coding ToolsAccording to the JetBrains AI Pulse Survey, 18% of developers report using Cursor at work, while GitHub Copilot...
• The Best MCP Servers for Cline: Top Model Context Protocol IntegrationsThe Model Context Protocol reached approximately 97 million monthly downloads by March 2026 [Digital Applied 2026...

More on this subject: Cline (104 guides)

Much of the online discussion surrounding custom modes in Cline stems from confusion between official upstream Cline and Roo Code, a popular community fork. In late 2024, Roo Code diverged from the original Cline codebase specifically to introduce a feature branded as Custom Modes. Roo Code allows developers to create arbitrary operational roles stored in a .roomodes configuration file, assigning each persona specific tool groups (read, edit, command, browser, mcp) and file regex restrictions.

Official upstream Cline, maintained by Cline Bot Inc. and hosted on the official Cline repository, takes a different architectural approach. Instead of exposing an arbitrary dropdown menu of user-defined modes, upstream Cline structures agent interactions around a native Plan & Act dual-mode architecture:

• Plan Mode: A dedicated exploration and strategy environment. In Plan mode, Cline can read files, inspect directory trees, search codebases, and discuss technical approaches. File modification tools (write_to_file, replace_in_file) and terminal command execution tools (execute_command) are physically disabled by the extension. Cline cannot alter repository state while in Plan mode.
• Act Mode: The implementation environment. Once an engineer approves the architectural proposal developed during Plan mode, switching to Act mode unlocks write access and command execution, subject to granular user confirmation prompts.

To create specialized personas in upstream Cline, developers configure .clinerules files. Cline checks for project-level rules in a .clinerules file located at the root of the workspace directory. For cross-project defaults, Cline reads global rules stored in ~/Documents/Cline/Rules on macOS and Windows, or ~/Cline/Rules on Linux.

By pairing structured rule files with Cline's native Plan and Act modes, teams can establish three foundational agent personas:

1. The Architect Persona

The Architect persona focuses on high-level system design, boundary mapping, and implementation planning. When running Cline in Plan mode with Architect rules, the agent is instructed to produce Markdown specifications rather than raw code.

Add the following persona block to your .clinerules:

### Architect Persona Guidelines
When operating in Plan Mode:
- Act as a Principal Software Architect.
- Never suggest code modifications without first mapping module dependencies.
- Structure all proposals with: Context, Problem Statement, Proposed Changes, Impacted Files, and Rollback Strategy.
- Formulate questions to clarify edge cases before finalizing any specification.
- Output plans as clear Markdown checklists that can be executed sequentially.

2. The Ask and Exploration Persona

The Ask persona functions as an interactive technical guide and codebase tutor. It explains system architecture, traces execution paths, and documents existing endpoints without proposing refactors.

### Ask Persona Guidelines
When answering codebase queries:
- Explain how components connect using file paths and symbol names.
- Trace data flows through controllers, services, and repositories step by step.
- Provide illustrative code snippets in response text rather than staging file edits.
- Cite relevant internal documentation when explaining system behavior.

3. The Strict Code Reviewer Persona

The Code Reviewer persona activates during Act mode, inspecting diffs against team standards before changes are committed.

### Code Reviewer Persona Guidelines

When reviewing or modifying code in Act Mode:
- Check all modified functions for explicit error handling and input validation.
- Verify that new endpoints include accompanying unit tests with boundary checks.
- Reject any change that introduces unvetted external dependencies.
- Ensure variable naming matches existing repository patterns.

Coordinate Cline agent personas in shared team workspaces

Connect Cline, Claude, and your engineering team to persistent, versioned workspaces with remote MCP access and built-in semantic search. Every organization starts with a 14-day free trial.

Start 14-Day Trial

Personas require more than prompt instructions; they depend on tool restrictions. While prompt guidelines encourage a model to behave like an architect, hard tool boundaries prevent the model from executing destructive operations if it experiences instruction drift.

Cline manages external integrations through the Model Context Protocol (MCP). Settings are defined in cline_mcp_settings.json, located within the extension's global storage directory:

• macOS: ~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
• Windows: %APPDATA%\\Code\\User\\globalStorage\\saoudrizwan.claude-dev\\settings\\cline_mcp_settings.json
• Linux: ~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json

Inside cline_mcp_settings.json, external capabilities are registered under the mcpServers object. Teams can connect Cline to remote workspaces using Streamable HTTP at https://mcp.fast.io/mcp/code. Setup guidance is available in the Fast.io MCP documentation. The following configuration connects Cline to Fast.io for agents for persistent team context:

{
  "mcpServers": {
    "fastio": {
      "type": "streamableHttp",
      "url": "https://mcp.fast.io/mcp/code"
    }
  }
}

Cline authenticates using OAuth in the browser rather than an API key in configuration. During sign-in, a Review Permissions screen prompts the user to select Read Only or Read & Write permissions and choose which organizations and workspaces the connection can reach.

Through this remote MCP connection, Cline gains access to a consolidated MCP toolset. An Architect persona can query shared team documentation, inspect product requirements, and check architectural standards stored in Fast.io without needing direct file write permissions on production repositories.

Configuring individual personas inside Cline solves task-level execution safety, but team-level development requires coordinating multiple personas across different machines. In a production workflow, one engineer might use Cline in Plan mode as an Architect to draft an implementation spec, while a second engineer uses Cline in Act mode to build the code. Without a shared storage layer, handing off context between these personas requires copy-pasting Markdown files across chat windows.

Teams often attempt to solve this handoff using commodity cloud storage like Google Drive or Dropbox. However, standard sync drives are designed for manual office document sharing, lacking developer-centric APIs and real-time agent access. Object storage services like Amazon S3 provide raw programmatic access, but they lack built-in semantic search, live document co-editing, and human-friendly audit trails.

Fast.io acts as an intelligent workspace platform designed for agentic teams, providing the persistent coordination layer where agent personas and human engineers collaborate. By integrating Cline with /storage-for-agents/, development teams centralize project context in shared, organization-owned workspaces.

Fast.io maintains per-file version history on every asset. When an Architect persona publishes an Architecture Decision Record (ADR) and a developer agent updates related interface specs, Fast.io records each modification as a distinct version. If an automated run produces incorrect documentation, team leads can review the diff and restore earlier versions instantly.

The platform also features an append-only audit log, recording which agent or human touched each file and when. Collaborative Notes allow engineers and agents to co-edit live implementation checklists in real time. Fast.io also includes Intelligence Mode, which automatically indexes uploaded files for semantic search. When a Cline agent connects via MCP, it can query the entire workspace using natural language, retrieving relevant architecture guidelines with verifiable source citations.

Every organization starts with a 14-day free trial, which requires a credit card. Plans include Starter at $9.99/mo, Business at $49.99/mo, and Enterprise at $199.99/mo on Fast.io pricing.