Conversations and Messages

Conversation Operations

• Create conversation
• Search conversation
• Rename conversation
• Pin conversation
• Delete conversation
• Isolated run state per conversation
• Conversation model selection (each conversation can independently select a model)

Conversation Model Selection

Each conversation can independently select which model to use:

• Click the model dropdown above the chat input area to select a model
• Model changes are automatically saved to the current conversation
• Different conversations can use different models to meet different task requirements
• New conversations default to the project's last selected model or the default model

Use cases:

• Select high-performance models for complex reasoning tasks
• Choose fast models for simple conversations to save costs
• Use the most suitable model for different topic conversations

Pin Conversation

Pin important conversations to keep them at the top of the conversation list:

• Click the pin button on the right side of the conversation title to toggle pin status
• Pinned conversations show a filled pin icon
• Unpinned conversations show an outline pin icon on hover
• Pinned conversations are sorted to the top of the list for quick access

Message Interaction

• Send prompts from input box
• Assistant streams responses in real time
• While a conversation is running, the send button switches to a Stop button
• Clicking Stop interrupts the current conversation run and active agent execution
• thinking content can stream in real time (if produced by the model)
• Agent tool calls are shown as tool messages (start/end/status/result)
• Installed agents are also exposed to the model as tools; when selected, they create agent tickets instead of executing synchronously inside the same turn
• Message history is stored per conversation

Slash Commands

Typing / opens a quick command autocomplete menu:

• Select compact to trigger context compaction
• Select skill:<name> to invoke an installed Skill
• Type to filter commands by name

Message Actions

• Each message shows a copy button on hover; click to copy the message content
• Long tool results are automatically collapsed; click to expand and view full content
• Tool messages display execution status indicators (running/success/failed)

Plan Mode

Each conversation can switch between normal chat mode and Plan mode:

• Choose Plan from the mode menu near the message composer
• Plan mode affects only the current conversation, not the whole project or other conversations
• In plan mode, the Assistant prioritizes producing a structured implementation plan instead of immediately changing files or running work
• After a plan is generated, the chat shows a Proposed Plan card
• Click Implement plan to exit plan mode and continue with that plan as the implementation basis
• Click Keep planning to stay in plan mode and revise constraints, steps, or alternatives

Use it when:

• Requirements need review before execution
• A code change, data operation, or external tool call has meaningful risk
• You want a shareable step list before asking the Assistant to act

Assistant Follow-up Questions

When the Assistant needs your decision, parameters, or confirmation before continuing, it can use the ask_user_question tool to create a structured question request:

• The question card appears above the composer; normal typing is temporarily locked while an answer is pending
• A request can contain up to 3 questions, shown as switchable tabs
• Questions can include options, optional custom answers, and reference cards for papers or candidate sources
• After all required questions are answered, click Submit; ResearchX sends the answers back into the current conversation and continues
• If the request is no longer needed, click the close button to dismiss it

This is useful for:

• Choosing among analysis paths, files, candidate papers, or parameters
• Letting the Assistant confirm high-level decisions instead of guessing
• Resuming an interrupted external-channel or long-running task from the project page

Answer Reliability

System instructions ask the Assistant to avoid presenting unverified guesses as facts:

• When information is insufficient, the Assistant should state uncertainty instead of inventing details
• When your decision is required, it should prefer a structured follow-up question
• When current facts, prices, policies, or external sources matter, it should use enabled search or external tools, or clearly say it cannot verify them
• Literature, data, and file references should be grounded in visible context or tool results

Message Editing and Branches

You can edit historical user messages directly. The system will resend the edited content and create a new conversation branch:

• Hover over an editable user message and click the edit button on the right
• The edit entry is only shown when the project is writable and the current conversation is idle
• After editing, the system resends the message with the updated content and starts a new branch from that point
• The original branch is kept and is not overwritten
• When a message has multiple versions, Previous version / Next version buttons appear on the right side of the message
• Switching versions loads the follow-up messages for that branch, which makes it easy to compare different edits

Recommended usage:

• Edit the message directly when you want to refine a prompt, add missing context, or correct an input mistake
• If you want to keep multiple attempts, create a new branch first and then continue each version separately
• Branch-based edits are useful for debugging, comparing approaches, and trying alternatives without copying the full history

Message Export

For Assistant messages (non-user, non-tool messages), the system provides two export options:

1. Download to device: Click the download button on the right side of the message and select "Download to device" to save the message content as a Markdown file (.md) to your device
2. Save to workspace: Click the download button and select "Save to workspace" to save the message to the project's working directory, making it accessible for Agent processing or further reference

Exported filenames follow the format chat-message-assistant-{timestamp}.md, where the timestamp is derived from the message creation time.

Use cases:

• Export important messages before context compaction to preserve details that may be lost
• Save valuable responses to the workspace for reference in subsequent tasks
• Download key conversations to your device for reports or archival purposes

Context Compaction

Overview

When conversation history grows long, the context window may approach or exceed the model's limit. Compaction generates a summary checkpoint, compressing earlier dialogue into a condensed form while preserving key information, thereby freeing up context space.

Trigger Methods

Manual Compaction

Type /compact in the input box, or type / and select compact from the quick command list.

You can append custom instructions:

/compact focus on code changes and error messages

The system passes your instruction to the summarization model to guide its focus.

Automatic Overflow Compaction

When the model API returns a context overflow error, the system automatically triggers compaction:

• Detects errors like "context length exceeded" and generates a summary of earlier dialogue
• Automatically retries the original request after compaction
• The entire process is transparent to the user, requiring no manual intervention

Preemptive Compaction (Pre-turn)

Administrators can configure a "preemptive compaction threshold" (e.g., 0.8 for 80%) in model settings:

• When context usage exceeds the threshold, compaction is triggered automatically before sending a message
• Avoids waiting for API errors, providing a smoother user experience
• Displays a notification after compaction, then continues with the original request

Configuration (Administrator):

1. Navigate to "Model Management"
2. Edit model configuration
3. Set "Preemptive Compaction Threshold" (0-1, e.g., 0.8 for 80%)
4. Leave empty or set to 0 to disable preemptive compaction

Compaction Result

When compaction succeeds, the conversation shows a Context Compressed message card:

• This card stores the compressed summary checkpoint
• Subsequent prompts replay from "latest summary + new turns after it"
• If there is no earlier conversation to summarize, the system returns Nothing to compact yet.

Technical Details

Usage Recommendations

1. Periodic compaction: Run /compact after a long planning, debugging, or implementation phase
2. Related task continuation: Continue in the same conversation if you want the summary to remain relevant
3. New task, new conversation: Start a new conversation for unrelated tasks to avoid history noise

Context Usage Monitoring

The system monitors and displays current conversation context usage in real time:

• A circular indicator shows current usage ratio
• Click to view detailed statistics: current tokens, peak tokens, remaining space
• When usage approaches the context window limit, consider running /compact proactively

Important Notes

• Compaction is irreversible; original dialogue details may be lost after summarization
• Consider compaction after important decision points, not too frequently
• Export the conversation beforehand if you need to preserve complete history

Run Control (New)

• Stop only affects the current conversation and does not affect other conversations
• If multiple conversations are running, stopping one does not interrupt the others
• After stopping, already generated and persisted messages remain in conversation history
• For docker-based agent tool calls, stop also propagates cancellation to avoid continued execution

Agents

The chat path no longer uses a separate agent-intent JSON classification step. Instead, agent execution is triggered through tool calling inside the main conversation loop:

• Each installed agent is exposed as its own tool
• Only agents installed in the current project, with complete dependencies, are exposed
• Calling an agent tool creates an agent ticket and renders an agent execution card in chat
• Agent cards show:
  • the agent used
  • which action was called at each step
  • step parameters
  • failure reasons, including docker action errors

Multiple Agent Concurrent Execution

Each conversation turn supports triggering multiple Agent tasks simultaneously:

• The system automatically coordinates the execution order of multiple concurrent Agents
• When multiple Agents are triggered together, a confirmation queue allows sequential user approval
• Each Agent's execution status and results are displayed independently

Conversation Continuation

After an Agent ticket completes, you can continue the conversation in the same session:

• Agent execution results are automatically added to conversation history
• Subsequent messages can reference Agent outputs
• Maintains complete context continuity

Model Selection

• Each prompt is sent with the currently selected model
• If no previous selection exists for a project, the first available model is auto-selected

Agent Tools (Current)

The chat agent currently exposes 6 built-in tools:

• read: read file contents from the project workspace
• bash: execute shell commands inside the project workspace
• edit: perform precise text edits in files
• write: create or overwrite files
• web_search: search the web for recent and factual information using Tavily API (see Web Search for configuration)
• get_agent_task_result: load the full result of a previously completed agent task (automatically available when agent confirmation is required)

Read Tool Image Preview

When an agent uses the read tool to read an image file, the chat interface automatically displays an inline preview:

• Supported formats: PNG, JPG, JPEG, GIF, WebP, SVG, BMP
• The preview appears within the tool message card
• If the image fails to load, an error message is displayed
• Image paths are automatically normalized for container path differences (e.g., /workspace/ prefix)
• find, grep, and ls are read-only tools for browsing and searching the project workspace
• When an Agent uses these read-only tools from a containerized environment, prefer project workspace paths such as /workspace/src or /workspace/.agent
• The system automatically maps /workspace/... paths used by these read-only tools to the real project directory, keeping directory listings and search scope consistent across environments

Additional notes:

• Tool execution is streamed as tool messages (start/end/success/error)
• /skill:<name> is not a separate tool; it expands into instructions executed via the tools above
• These tools operate in the current project's local workspace, not the repository root
• In docker-backed execution, the in-container workspace root is /workspace
• Agents are no longer redundantly injected into the system prompt; the model sees them through registered agent tools

Tool Permission Confirmation

Overview

When an Agent attempts file writes (write), file edits (edit), or mutating shell commands (bash mutations) during a conversation, the system checks the project configuration to determine whether user approval is required. This ensures users retain full control over every file change and command execution performed by the AI.

Confirmation Trigger Rules

The system applies the following rules to decide whether confirmation is needed:

Bash Command Classification

The system automatically classifies Bash commands as read-only or mutating:

• Mutating commands (require confirmation): rm, mv, cp, mkdir, chmod, chown, sed -i, perl -pi, patch, git apply, shell redirections (>/>>), tee, script interpreters (python/node/bash, etc.), find -exec, xargs, heredocs
• Read-only commands (auto-allow): ls, cat, head, tail, grep, find (without -exec), echo (without redirection), which, pwd, etc.

Confirmation Panel

When a tool call requires confirmation, a Tool Permission Panel appears at the top of the chat area:

1. The panel displays the tool name (e.g., write, edit, bash), the operation title, and a content summary
2. Target file paths or command content are shown
3. The reason for confirmation is displayed (e.g., "Manual mode requires confirmation for this file-changing tool call")
4. Click Approve to execute the tool call and continue the conversation
5. Click Deny to reject the tool call and stop the current conversation execution

Diff Preview

For pending write and edit requests, the confirmation panel can show a line-based diff preview before you approve the tool call:

• Text files are rendered as hunks with additions, deletions, and context lines
• Large files, binary files, missing targets, and ambiguous edit matches fall back to a summary or excerpt instead of a full diff
• The preview is read-only and does not store extra workspace state

Revert Applied Changes

After a file-changing tool call has already been executed, the tool card can show the executed diff and a Revert changes action:

• Click Revert changes to open a confirmation panel listing the affected files and their status
• Click Confirm revert to restore the previous contents
• Added files are removed, deleted files are restored, and modified files are rolled back to their earlier content
• If the workspace changed after the tool ran, the revert is blocked and the card shows which file caused the conflict
• When a conflict happens, the workspace is left untouched

Batch Confirmation

When multiple tool calls requiring confirmation are triggered in a single conversation turn, the confirmation panel shows all pending requests in order for sequential user approval.

Configuration

• Auto-run mode: Enable in project settings to allow all tool calls to execute automatically without manual confirmation
• Manual confirmation mode (default): Every file change and mutating shell command requires explicit user approval

Security Notes

• In standard mode, Agents cannot modify files under .agent/ (except memory.md and the memory/ subdirectory), preventing Agents from altering their own skill or action definitions
• Dev mode has no such restriction, allowing Agents to modify all files under .agent/
• Permission request statuses include: pending, approved, denied, executed, expired

Best Practice

Use separate conversations for distinct research sub-topics for easier reuse.