How to Configure Collaboration Modes for Different Workflows in DeepSeek-Reasonix

DeepSeek-Reasonix provides three distinct collaboration modes—normal, plan, and goal—that control how the AI agent interacts with users, executes tools, and persists objectives across sessions.

DeepSeek-Reasonix structures agent-user interaction through configurable collaboration modes defined in the desktop application layer. These modes determine whether the agent operates in an immediate execution posture, a read-only planning state, or an autonomous goal-tracking configuration, allowing developers to match the agent's behavior to specific workflow requirements.

Understanding the Three Collaboration Modes

DeepSeek-Reasonix implements three canonical collaboration modes stored as JSON-serialized metadata in each desktop tab. According to the specification in docs/SPEC.md, these modes determine how the agent balances user direction against autonomous action.

Normal Mode

Normal mode represents the default operational state where the agent follows user prompts directly and executes tools as requested. This mode suits day-to-day coding, debugging, and ad-hoc tasks requiring immediate feedback. When active, the agent maintains no persistent goal state and processes each turn independently.

Plan Mode

Plan mode switches the agent into a plan-only posture that blocks all writer-type tools—including file edits and Bash commands—until explicitly exited. This mode prevents accidental mutations while the model reasons, outlines strategies, or explores implementation ideas. In desktop/app.go, entering plan mode triggers tabModeFromAxes(true, ...) which sets the internal plan flag to true while clearing any active goal.

Goal Mode

Goal mode attaches an autonomous objective to the session that persists across turns. The goal text prepends to every user input, and the model continues generating turns until reporting the goal as completed. This mode supports long-running jobs such as "implement feature X," research projects, or multi-step migrations. The Goal and GoalStatus fields in the tab metadata maintain this state according to the implementation in desktop/tabs.go lines 860-874.

Setting Collaboration Modes Programmatically

The application exposes specific APIs to configure collaboration modes at runtime, with each desktop tab maintaining independent mode settings.

Core API Methods

Use these methods defined in desktop/app.go to manipulate collaboration states:

• SetCollaborationMode(mode) — Sets the mode for the active tab (empty tabID)
• SetCollaborationModeForTab(tabID, mode) — Sets the mode for a specific tab, enabling multi-tab workflows
• normalizeCollaborationMode(mode) — Internal helper mapping case-insensitive input to canonical strings "normal", "plan", or "goal" (see implementation at lines 81-89)

Implementation Example

The following Go code demonstrates how SetCollaborationModeForTab handles mode transitions while preserving tool-approval settings:

func (a *App) SetCollaborationModeForTab(tabID, mode string) {
    mode = normalizeCollaborationMode(mode)           // Canonicalize input
    a.mu.Lock()
    tab := a.tabByIDLocked(tabID)
    if tab == nil {
        a.mu.Unlock()
        return
    }
    approvalMode := currentTabToolApprovalMode(tab)   // Preserve tool-approval
    
    switch mode {
    case "plan":
        tab.mode = tabModeFromAxes(true, approvalMode == control.ToolApprovalYolo)
        tab.goal = ""                                 // Clear active goal
    case "goal":
        tab.mode = tabModeFromAxes(false, approvalMode == control.ToolApprovalYolo)
        // Goal persists via SetGoalForTab
    default: // "normal"
        tab.mode = tabModeFromAxes(false, approvalMode == control.ToolApprovalYolo)
        tab.goal = ""
    }
    
    // Propagate to controller
    ctrl := tab.Ctrl
    goal := tab.goal
    plan := tabModeHasPlan(tab.mode)
    a.mu.Unlock()
    if ctrl != nil {
        ctrl.SetPlanMode(plan)   // Block/unblock writers
        ctrl.SetGoal(goal)       // Update goal text
    }
    
    // Persist changes
    a.mu.Lock()
    a.saveTabsLocked()
    a.mu.Unlock()
}

Source: desktop/app.go implementation lines 896-904.

Practical Usage Examples

Set the active tab to plan mode:

app.SetCollaborationMode("plan")

Configure a specific tab for autonomous goal execution:

tabID := "tab-1234"
app.SetCollaborationModeForTab(tabID, "goal")
app.SetGoalForTab(tabID, "Implement the new authentication flow")

Query the current mode programmatically:

mode := currentTabCollaborationMode(tab) // Returns "normal", "plan", or "goal"

Source: desktop/tabs.go lines 4738-4746.

Using CLI Commands and UI Controls

DeepSeek-Reasonix exposes collaboration mode switching through both graphical interfaces and slash commands.

Slash Command Interface

The command parser in internal/command/command.go implements shortcuts that normalize to the API methods:

/plan          # Enter plan mode

/goal Refactor the data layer   # Start goal mode with description

/normal        # Return to normal mode

These commands forward normalized mode strings to SetCollaborationModeForTab, making them functionally equivalent to programmatic API calls.

Desktop UI Integration

The desktop application renders a Collaboration dropdown presenting the three modes as 正常模式 (normal), 计划模式 (plan), and 目标模式 (goal). Selecting an entry invokes the corresponding API method without disrupting the underlying tool-approval configuration.

How Collaboration Modes Interact with Tool Approvals

Collaboration mode operates orthogonally to the tool-approval posture (ask/auto/yolo). Changing the collaboration mode modifies only the collaboration flag; the permission layer remains untouched.

For example, if a user enables yolo for automatic tool approvals, entering plan mode still blocks all writer tools—the planner remains read-only—but the underlying yolo flag persists for future normal or goal sessions. This separation allows safe planning within high-automation environments without permanently altering approval settings.

Source: Architecture specification in docs/SPEC.md section 3.5 and implementation in desktop/app.go lines 304-311.

Persisting Mode Settings Across Sessions

The desktop application persists collaboration configuration through the tab metadata system. When the application shuts down, saveTabsLocked() serializes each tab's CollaborationMode string (and Goal/GoalStatus when applicable) to disk.

On restart, the application reloads this metadata, automatically restoring the last-used collaboration mode for each tab. This persistence mechanism ensures that long-running goals survive application restarts without requiring manual reconfiguration.

Summary

• DeepSeek-Reasonix supports three collaboration modes: normal for immediate execution, plan for read-only strategy sessions, and goal for autonomous objective tracking.
• Use SetCollaborationModeForTab to programmatically configure modes per tab, with normalizeCollaborationMode handling input validation.
• Collaboration mode is orthogonal to tool approvals, meaning plan mode blocks writers regardless of whether approvals are set to ask, auto, or yolo.
• Settings persist automatically via saveTabsLocked() in desktop/app.go, restoring your workflow state across application restarts.

Frequently Asked Questions

What is the difference between plan mode and goal mode in DeepSeek-Reasonix?

Plan mode blocks all writer-type tools and clears any active goal, creating a safe environment for reasoning and strategy development without file mutations. Goal mode allows tool execution while attaching a persistent objective that prepends to every user turn, enabling autonomous multi-step execution until the goal completes. Plan mode emphasizes safety; goal mode emphasizes autonomy.

Does changing collaboration mode affect tool approval settings?

No. Collaboration mode and tool-approval posture (ask/auto/yolo) are deliberately orthogonal concepts. Switching to plan mode blocks writers internally but preserves your approval configuration for when you return to normal or goal mode. This design prevents accidental configuration changes while workflow contexts shift.

How do I set a collaboration mode for a specific tab rather than the active one?

Use the SetCollaborationModeForTab(tabID, mode) method, which accepts a specific tab identifier string. This API enables complex multi-tab workflows where different tabs maintain different collaboration postures—for example, one tab in plan mode for architecture review while another in goal mode for implementation.

Where does DeepSeek-Reasonix store collaboration mode settings?

Each desktop tab stores a CollaborationMode string in its JSON-serialized metadata, along with Goal and GoalStatus fields when applicable. The saveTabsLocked() method in desktop/app.go persists these values to disk, and they reload automatically when the application restarts, maintaining your workflow continuity.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}