Skip to main content

Feature Settings

Feature Settings allow you to customize advanced functionality and experimental features in PostQode. These settings control specific behaviors and capabilities that enhance your development workflow.

Accessing Feature Settings​

  1. Open VS Code with PostQode extension installed
  2. Click on the PostQode icon in the sidebar to open the PostQode panel
  3. Click on the Settings icon (gear icon) in the PostQode panel
  4. Navigate to the Feature Settings section

Workspace Management​

Enable Checkpoints​

Default: Disabled

Enables the extension to save checkpoints of your workspace throughout task execution using Git under the hood.

How Checkpoints Work​

  • Automatic Snapshots: Creates Git commits at key points during task execution
  • Version History: Maintains a history of changes made by PostQode
  • Rollback Capability: Allows you to revert to previous states if needed
  • Branch Management: Uses Git branches to isolate checkpoint history

Benefits​

  • Safety Net: Easily revert changes if something goes wrong
  • Change Tracking: See exactly what PostQode modified in your workspace
  • Collaboration: Share checkpoint history with team members
  • Debugging: Identify when and where issues were introduced

Requirements​

  • Git Repository: Your workspace must be a Git repository
  • Git Installed: Git must be installed and accessible from command line
  • Write Permissions: PostQode needs write access to the workspace
  • Clean Working Directory: Works best with committed changes

Limitations​

  • Large Workspaces: May not work well with very large repositories
  • Performance Impact: Can slow down operations in large projects
  • Storage Usage: Creates additional Git history and objects
  • Merge Conflicts: May complicate Git workflows in active repositories

Best Practices​

  • Small to Medium Projects: Works best with reasonably sized codebases
  • Dedicated Branches: Consider using separate branches for PostQode work
  • Regular Cleanup: Periodically clean up checkpoint branches
  • Backup Important Work: Always backup critical work before enabling

Configuration Steps​

  1. Ensure your workspace is a Git repository
  2. Navigate to Feature Settings
  3. Toggle "Enable Checkpoints" on
  4. PostQode will create checkpoints automatically during task execution
  5. View checkpoint history using Git commands or your Git client

MCP (Model Context Protocol) Features​

Enable MCP Marketplace​

Default: Enabled

Enables the MCP Marketplace tab for discovering and installing MCP servers that extend PostQode's capabilities.

What is MCP Marketplace​

  • Server Discovery: Browse available MCP servers from the community
  • Easy Installation: One-click installation of MCP servers
  • Server Management: Manage installed servers and their configurations
  • Community Contributions: Access servers created by the PostQode community

Benefits​

  • Extended Functionality: Add new tools and capabilities to PostQode
  • Specialized Tools: Access domain-specific tools and integrations
  • Community Innovation: Leverage community-developed enhancements
  • Modular Architecture: Add only the features you need

How to Use​

  1. Enable "Enable MCP Marketplace" in Feature Settings
  2. Navigate to the MCP Marketplace tab in PostQode panel
  3. Browse available servers by category or search
  4. Click "Install" on servers you want to add
  5. Configure server settings as needed

MCP Display Mode​

Options: Plain Text | Rich Display | Markdown

Default: Rich Display

Controls how MCP server responses are displayed in the PostQode interface.

Display Mode Options​

Plain Text​
  • Simple Format: Displays responses as plain text
  • Fast Rendering: Minimal processing for quick display
  • Low Resource: Uses minimal system resources
  • Best For: Simple text responses and low-powered systems
Rich Display​
  • Enhanced Formatting: Supports links, images, and rich formatting
  • Interactive Elements: Clickable links and interactive components
  • Visual Appeal: Better visual presentation of complex data
  • Best For: Complex responses with multimedia content
Markdown​
  • Markdown Rendering: Full markdown support with syntax highlighting
  • Code Blocks: Proper formatting for code snippets
  • Tables and Lists: Enhanced display of structured data
  • Best For: Technical documentation and code-heavy responses

Collapse MCP Responses​

Default: Enabled

Sets the default display mode for MCP response panels to collapsed state.

Benefits​

  • Clean Interface: Keeps the interface uncluttered
  • Focus Management: Helps maintain focus on current tasks
  • Performance: Reduces rendering overhead for large responses
  • User Control: Users can expand responses when needed

Configuration​

  • Enabled: MCP responses start collapsed by default
  • Disabled: MCP responses are fully expanded by default
  • Per-Response: Users can still expand/collapse individual responses

AI Model Features​

OpenAI Reasoning Effort​

Options: Low | Medium | High

Default: Medium

Controls the reasoning effort level for OpenAI family models across all OpenAI model providers.

Reasoning Effort Levels​

Low Effort​
  • Fast Responses: Prioritizes speed over deep reasoning
  • Lower Cost: Reduced token usage and API costs
  • Simple Tasks: Best for straightforward questions and tasks
  • Quick Iterations: Ideal for rapid prototyping and testing
  • Balanced Performance: Good balance of speed and reasoning quality
  • Moderate Cost: Reasonable token usage for most tasks
  • General Purpose: Suitable for most development tasks
  • Default Choice: Recommended for typical usage patterns
High Effort​
  • Deep Reasoning: Maximum reasoning capability and accuracy
  • Higher Cost: Increased token usage and API costs
  • Complex Tasks: Best for complex problem-solving and analysis
  • Quality Focus: When accuracy is more important than speed

When to Adjust​

  • Increase for: Complex debugging, architectural decisions, code reviews
  • Decrease for: Simple questions, quick fixes, repetitive tasks
  • Consider Cost: Higher effort levels consume more tokens

Chat and Interaction Features​

Enable Strict Plan Mode​

Default: Disabled

Enforces strict tool use while in Plan mode, preventing file edits and system modifications.

Strict Mode Behavior​

  • Read-Only Operations: Only allows reading files and viewing information
  • No File Edits: Prevents writing, modifying, or deleting files
  • No System Changes: Blocks system commands and configuration changes
  • Safe Exploration: Allows safe exploration of codebases without modifications

Benefits​

  • Safety: Prevents accidental modifications during exploration
  • Code Review: Safe for reviewing code without risk of changes
  • Learning: Ideal for learning and understanding existing codebases
  • Collaboration: Safe for shared environments and pair programming

When to Enable​

  • Code Reviews: When reviewing code without intending to modify
  • Learning: When exploring unfamiliar codebases
  • Demonstrations: When showing code to others
  • Shared Environments: When working in shared or production environments

Limitations​

  • No File Creation: Cannot create new files or directories
  • No Modifications: Cannot fix bugs or implement features
  • Limited Assistance: Reduces PostQode's ability to help with implementation
  • Mode Switching: Need to disable for actual development work

Enable Focus Chain​

Focus Chain is a task management enhancement feature in PostQode that provides automatic todo list management with real-time progress tracking throughout your tasks. ​

Automatic Todo List Generation​

PostQode analyzes your task and automatically creates a comprehensive todo list with:

  • Clear, actionable items in markdown checklist format
  • Logical breakdown of complex tasks into manageable steps
  • Real-time updates as work progresses ​

User-Editable Todo Lists​

Todo lists are stored as editable markdown files:

  • Direct editing through your preferred markdown editor
  • Automatic detection of changes you make
  • Seamless integration back into Cline’s workflow
  • Quick access through the edit button in the task header ​

Visual Progress Tracking​

The task header displays clear progress indicators:

  • Step counters showing current progress (e.g., “3/8”)
  • Completed items clearly marked with checkmarks
  • Current work highlighted with indicators
  • Expandable view to see the full todo list

Context Management​

Enable Auto Compact​

Default: Enabled

Enables advanced context management system which uses LLM-based condensing for next-generation models.

How Auto Compact Works​

  • Intelligent Summarization: Uses AI to summarize old conversation context
  • Context Preservation: Maintains important information while reducing token usage
  • Automatic Triggering: Activates when context approaches token limits
  • Seamless Operation: Works transparently without user intervention

Benefits​

  • Extended Conversations: Allows longer conversations without hitting limits
  • Cost Efficiency: Reduces token usage by compacting old context
  • Performance: Maintains response speed by managing context size
  • Continuity: Preserves conversation flow and important context

Technical Details​

  • LLM Processing: Uses the same model to intelligently summarize context
  • Selective Compression: Preserves recent and important information
  • Threshold Management: Automatically triggers at optimal context levels
  • Quality Preservation: Maintains conversation quality and coherence

Considerations​

  • Processing Time: Brief delay when compacting occurs
  • Information Loss: Some minor details may be lost in summarization
  • Model Dependency: Requires compatible models for optimal performance
  • Token Usage: Uses additional tokens for the compacting process

Enable Multi-Root Workspace​

Multiroot Workspace Support​

PostQode’s Multiroot feature works seamlessly with VSCode’s multi-root workspaces, letting you manage multiple project folders in a single workspace.

Important: Multi-root workspaces are currently an experimental feature and have the following limitations:

  • PostQode rules only work in the first workspace folder
  • Checkpoints are automatically disabled with a warning message
  • Both features are restored when you return to a single-folder workspace

What is multiroot workspace support?​

Instead of being limited to one project folder, PostQode can read files, write code, and run commands across all folders in your VSCode workspace.
This is especially helpful when working with monorepos, microservices, or multiple related projects.

How it works​

When you open multiple workspace folders in VSCode, PostQode automatically:

  • Designates one folder as the primary workspace (typically the first folder added)
  • Tracks all workspace folders and paths
  • Resolves file paths intelligently across workspaces
  • Displays workspace information in the environment details for each API request

Getting Started​

Setting Up Multi-Root Workspaces​

You can add folders to your workspace using:

  • File > Add Folder to Workspace in VSCode
  • Creating a .code-workspace file with multiple folder paths
  • Drag-and-drop folders into the File Explorer
  • Selecting multiple folders when opening a workspace

Once your workspace is ready, just start using PostQode — it automatically detects all your workspace folders and interacts with them as needed.

For detailed instructions on setting up multi-root workspaces in VS Code, refer to Microsoft’s official documentation.

Technical Behavior​

Workspace Detection​

  • PostQode detects all workspace folders when a task begins
  • The first folder becomes the primary workspace by default
  • Each workspace can have its own VCS (Git, SVN, etc.)

Path Resolution​

  • Relative paths resolve relative to the primary workspace
  • You can target specific workspaces using workspace hints: @workspaceName:path/to/file
  • PostQode intelligently determines which workspace a file belongs to

Command Execution​

  • Commands execute in the correct workspace context
  • The working directory is set based on where files are accessed

Working Across Workspaces​

Referencing Specific Workspaces​

You can naturally reference different workspaces in your prompts:

Ask PostQode
"Read the package.json in my frontend folder and compare it with the backend dependencies"

Native Tool Call​

The Native Tool Call feature allows PostQode to execute tool calls using a model’s own native tool processor rather than PostQode’s standard tool-handling system. This is intended for advanced reasoning models that internally manage tool execution.

What Native Tool Call Does​

When enabled, PostQode will:

  • Use the model’s native tool-calling API
  • Bypass PostQode’s default tool invocation system
  • Allow the model to decide when and how tools should be used
  • Provide deeper integration with models that implement their own tool-processing logic

Why This Feature Exists​

Some advanced reasoning models — such as:

  • moonshotai/Kimi-K2-Thinking on Baseten
  • Other models that support native tool-calling frameworks

require direct access to their internal tool processor to function properly.
Without this feature enabled, such models may:

  • Not call tools
  • Execute incomplete workflows
  • Produce degraded reasoning
  • Fail during tool planning sequences

When to Enable Native Tool Call​

Enable this only if all conditions apply:

✅ Use it when the model explicitly requires native tool calling​

Examples include models that state:

  • “Requires native tool calling”
  • “Uses built-in tool processor”
  • “Supports tool APIs natively”

✅ Use it when you want the model to control tool decisions autonomously​

Some reasoning models plan multi-step tool sequences internally.

❌ Do not enable if:​

  • You are using standard models (OpenAI, Google, Anthropic, etc.)
  • You want deterministic tool execution via PostQode’s default system
  • Your chosen model does not mention native tool support

How to Enable It​

Navigate to: Settings → Features → Enable Native Tool Call Toggle the feature ON.

Limitations (Experimental)​

Since this feature bypasses PostQode’s default tool processor:

  • Tool execution may be less predictable
  • Some safety checks may not apply
  • Error-handling will differ depending on the model
  • Tool logs may be reduced
  • Behavior will vary based on the model’s own design

This is expected because the model itself is handling tool execution, not PostQode.

YOLO Mode​

YOLO mode is exactly what it sounds like — PostQode auto-approves everything.
Check the box in feature settings and it will execute file changes, terminal commands, and even transitions from Plan to Act mode without asking.

Think of it as Auto Approve on steroids — instead of granular permissions, YOLO mode gives PostQode complete autonomy.

⚠️ Warning: YOLO mode is dangerous.
It disables all safety checks.
PostQode will execute whatever it decides without asking for permission.

What Gets Auto-Approved​

When YOLO mode is enabled, PostQode automatically approves:

  • All file operations — reading, writing, deleting, and modifying files anywhere on your system
  • All terminal commands — including potentially destructive operations
  • Browser actions — scraping, navigation, form submissions
  • MCP server tools — external integrations and API calls
  • Mode transitions — switching from Plan to Act automatically

Essentially, every safety guardrail is removed.
PostQode operates with complete autonomy.

How to Enable YOLO Mode​

Go to PostQode Settings → Features and check the “Enable YOLO Mode” box.

That's it — no confirmations, no extra warnings.
Once enabled, PostQode will start auto-approving all actions immediately.

To disable it, simply uncheck the box.
After disabling, any new actions will once again require your approval.

When You Might Use This​

YOLO mode was designed primarily for the upcoming scriptable CLI, where fully autonomous execution makes sense.

In the GUI, consider using it for:

  • Rapid prototyping — zero friction, ideal for throwaway experiments
  • Trusted, repetitive tasks — when you’ve validated the workflow and want speed
  • Demos & presentations — show PostQode’s full power without approval interruptions

What Could Go Wrong​

Since YOLO mode removes all safety checks, PostQode could:

  • Delete important files
  • Execute system-modifying commands
  • Make external network requests
  • Overwrite configuration files
  • Install or uninstall software
  • Commit & push changes automatically

The risk depends entirely on your instructions.
Simple tasks remain safe — complex requests can have unpredictable behavior.

Best Practices​

If you choose to use YOLO mode:

  • Use isolated environments first
    Try it in sandbox or experimental projects. Avoid production codebases.

  • Be extremely specific
    Vague instructions + unlimited permissions = dangerous outcomes.

  • Monitor output
    PostQode still shows what it’s doing — watch file changes and terminals.

  • Use version control as your safety net
    Git lets you rollback if something goes wrong.

Inspiration: What Becomes Possible​

With YOLO mode enabled, you can:

  • Build full applications from a single prompt
    PostQode handles file creation, dependencies, configuration, build scripts, etc.

  • Automate complex workflows
    Multi-step refactoring, data pipelines, infrastructure setup — all frictionless.

  • Rapidly iterate on new ideas
    No approval delays, perfect for experimentation and prototyping.

  • Run live demos
    Showcase PostQode’s full autonomous power without disruption.

YOLO mode transforms PostQode from a guided assistant into a fully autonomous agent.
Use that power wisely.

Is this documentation incorrect or incomplete? Report an issue on GitHub