Configuration File

Posit Assistant is configured through a JSON settings file. This file controls model selection, behavior preferences, runtime configuration, permissions, and more.

File Locations

📝 Directory change

In previous versions, the configuration directory was ~/.positai (global) and .positai/ (project-level). These have been renamed to ~/.posit/assistant and .posit/assistant/. Existing files are migrated automatically on first launch.

Posit Assistant uses two levels of configuration:

  • Global config applies to all projects. Located at:

    • macOS / Linux: ~/.posit/assistant/settings.json
    • Windows: %USERPROFILE%\.posit\assistant\settings.json
  • Project config overrides global settings for a specific project. Place a .posit/assistant/settings.json file in your project root.

Some settings (like providers, storage, and logging) are global-only. Others (like model, permissions, and MCP servers) can be set at either level, with project values taking precedence. The sections below indicate which level each setting supports.

Settings are resolved in this order (last wins): defaults → global config → project config → environment variables.

Per-Project Settings

The following settings can be set in either the global ~/.posit/assistant/settings.json or a project-level .posit/assistant/settings.json. Project values take precedence over global values.

Model Settings

KeyTypeDefaultDescription
model.idstring"claude-sonnet-4-6"The model to use for conversations.
model.providerstring"positai"The LLM provider. The default is "positai" (Posit AI — a managed service from Posit). See the Posit AI page for details.
model.thinkingEffortstringDefault thinking effort level for new conversations. During a conversation, thinking effort is adjusted via the UI and stored per-conversation.
model.webSearchbooleanfalseDefault web search preference for new conversations. During a conversation, web search is toggled via the UI and stored per-conversation.

Permissions

Control which capabilities the assistant can use. Each key is a permission key, usually a tool name (bash, read, edit, etc.), mapped to either an action string or an object of patterns for that capability’s match target. For example, bash patterns match commands, while task patterns match the subagent type requested through launchSubagent:

{
	"permission": {
		"bash": {
			"git *": "allow",
			"rm *": "deny"
		},
		"read": "allow",
		"edit": "ask",
		"task": {
			"explore": "deny",
			"general": "ask"
		}
	}
}

The former permission.explore key is no longer supported. Move its "allow", "ask", or "deny" value to permission.task.explore.

You can also set a single action for all tools as a shorthand:

{
	"permission": "ask"
}
KeyTypeDefaultDescription
permissionstring | objectPermission configuration. Set to "allow", "ask", or "deny" for all capabilities, or use per-key rules whose patterns match the relevant input, such as shell commands, file paths, or subagent types.
📝 Project vs. global permissions

When you grant or deny permissions through the UI, they are saved to your project-level .posit/assistant/settings.json. If you want permissions to apply across all projects, copy the permission block to your global ~/.posit/assistant/settings.json instead.

MCP Servers

Connect external tool servers using the Model Context Protocol.

{
  "mcpServers": {
    "my-server": {
      "type": "local",
      "command": ["node", "server.js"],
      "environment": {
        "API_KEY": "..."
      }
    },
    "remote-server": {
      "type": "remote",
      "url": "https://mcp.example.com",
      "headers": {
        "Authorization": "Bearer ..."
      }
    }
  }
}
KeyTypeDefaultDescription
typestring"local"Server type. "local" for stdio subprocess, "remote" for HTTP/SSE.
commandstring[]Command and arguments to start a local MCP server.
urlstringURL of a remote MCP server.
enabledbooleantrueWhether this server is active.
timeoutnumber10000Connection timeout in milliseconds.
📝 Project vs. global MCP servers

MCP servers can be configured in either the project-level .posit/assistant/settings.json or the global ~/.posit/assistant/settings.json. Project-level servers are merged with global servers by server name, with project values taking precedence. Use project-level config for project-specific servers and global config for servers you want available everywhere.

Skills

Control where Posit Assistant discovers custom skills.

KeyTypeDefaultDescription
skills.pathsstring[]["~/.agents/skills", "~/.posit/assistant/skills", ".agents/skills", ".posit/assistant/skills"]Directories to search for skills, processed in order. Paths starting with ~ or $HOME are expanded to the home directory. Relative paths are resolved against each workspace root.
📝 Skill name conflicts

When the same skill name exists in more than one directory, the version from the later directory is used.

📝 Project vs. global skill paths

When both global and project-level configs define skills.paths, the project value completely replaces the global value — paths are not merged. To extend the defaults, repeat them in your project config alongside any additions.

Plugins

Register plugin marketplaces and control which plugins are enabled. These keys are normally managed for you by the plugin manager, but you can also edit them directly. See Plugins & Marketplaces for the full feature guide.

Requires experimental features

The plugin manager and the /plugin and /marketplace commands are hidden unless features.experimentalFeatures is on. The keys below still take effect either way — a plugin enabled here contributes its skills, commands, and MCP servers regardless — so you can turn the flag off without breaking a workspace that depends on a plugin.

{
  "extraKnownMarketplaces": {
    "acme": { "source": "acme/plugins" }
  },
  "enabledPlugins": {
    "data-tools@acme": true
  }
}
KeyTypeDefaultDescription
extraKnownMarketplacesobject{}Declared plugin marketplaces, keyed by name. Each value gives the marketplace source (a GitHub owner/repo, a git URL, or a local path). Readable from a project config in a trusted workspace, where it merges with your global marketplaces.
enabledPluginsobject{}Plugin enablement keyed by "<plugin>@<marketplace>". true = enabled, false = installed but disabled, absent = not installed. Readable from a project config in a trusted workspace, where it merges with your global entries.
plugins.allowedComponentsstring[]all typesRestrict which component types a plugin may contribute (e.g. ["skills", "commands", "mcpServers"]). Unknown values are ignored. Omitted means no restriction. A project config can narrow this further but never widen it.
plugins.hostTokensobject{}Per-host git credential references for private marketplaces, as {env:VAR} environment-variable references only. Global scope only, so a project config cannot inject credentials.
📝 Project vs. global plugin keys

extraKnownMarketplaces, enabledPlugins, and plugins.allowedComponents can each be set globally or in a project config, and the plugin manager lets you choose which file it writes to. Project entries are only read in a workspace you have trusted, and they add to rather than replace your global entries. Downloaded plugin content always lives in your per-user store (~/.posit/assistant/plugins/) regardless of which config declared it. plugins.hostTokens is global-only and is never read from a project config, so a repository can never supply git credentials.

💡 Enterprise administration

On Posit Workbench with Positron, administrators can enforce a marketplace allowlist and denylist and a component ceiling that users cannot override. See Positron Settings.

Runtime Settings

Control how Posit Assistant connects to R and Python.

KeyTypeDefaultDescription
runtime.r.enabledbooleantrueEnable R runtime integration.
runtime.r.pathstring"Rscript"Path to the Rscript executable.
runtime.r.timeoutnumber30000Timeout in milliseconds for R code execution.
runtime.python.enabledbooleantrueEnable Python runtime integration.
runtime.python.pathstring"python3"Path to the Python executable.
runtime.python.timeoutnumber30000Timeout in milliseconds for Python code execution.

Workspace Settings

KeyTypeDefaultDescription
workspace.pathstring""Working directory. Defaults to the current directory.
workspace.allowedRootsstring[]Allowed root directories for workspace switching. Defaults to the user home directory.

Sandbox

Control sandbox mode for shell tool execution. On macOS and Linux, bash commands run inside an OS-level sandbox (macOS Seatbelt / Linux bubblewrap) that restricts writes to the workspace and temp directories, blocks network access, and prevents reading sensitive paths like ~/.ssh and ~/.aws. On Windows, the same setting enables gated mode for the active shell: commands are checked against a built-in allowlist before they run. This is not an OS-level sandbox.

KeyTypeDefaultDescription
sandbox.enabledbooleanfalseEnable sandboxing for shell tool execution.

You can also toggle sandbox mode during a session with the /sandbox command.

Tips

Control the helpful tips that appear above the input area. A tip always appears on startup; after each assistant turn, a tip appears with a small probability.

KeyTypeDefaultDescription
features.showTipsbooleantrueShow tips above the input after assistant turns and on startup.
💡 Positron users

In Positron, this setting is also available as assistant.showTips in the Settings UI. See Positron Settings for how values from both sources are merged.

Compaction

Control how Posit Assistant manages long conversations. See Context Management for details on how compaction works.

These settings go in the features block of your config file:

{
  "features": {
    "autoCompactTokenBuffer": 30000
  }
}
KeyTypeDefaultDescription
features.autoCompactTokenBuffernumber30000Tokens reserved for the compaction summary. Auto-compaction triggers once fewer than this many tokens remain in the context window.

Micro-compaction is controlled by the /microcompact command, not configuration. It runs only when you invoke it.

💡 Positron users

In Positron, compaction settings are read from the config file’s features block. assistant.autoCompactTokenBuffer can also be set via Positron’s settings.json, though it is not exposed in the Settings UI. See Positron Settings for how values from both sources are merged.

Cache Keepalive

Keep a supported model’s prompt cache warm while you read a response and step away. When enabled, Posit Assistant sends lightweight background “pings” after each turn so a follow-up message can reuse the cached conversation prefix. Cache lifetime and ping cadence depend on the selected model.

This is on by default. To turn it off or bound how long pings may be sent, set the features block in your settings file:

{
  "features": {
    "cacheKeepalive": false,
    "cacheKeepaliveMinutes": 30
  }
}
KeyTypeDefaultDescription
features.cacheKeepalivebooleantrueEnable cache-keepalive pings after a turn completes for models with a supported cache policy.
features.cacheKeepaliveMinutesnumber30Maximum wall-clock window after the last real model request during which automatic pings may be sent (0–60 minutes). This is a send deadline, not the cache-expiration time.
📝 Model-dependent timing

Claude and supported GPT-5.6 routes use different cache lifetimes and ping cadences. A successful final ping can keep the cache warm beyond the configured ping-send window. Changes to cacheKeepalive and cacheKeepaliveMinutes take effect on your next turn — no restart needed.

💡 Positron users

In Positron, these settings are also available as assistant.cacheKeepalive and assistant.cacheKeepaliveMinutes in Positron’s Settings UI. When set in both places, Positron merges them — see Positron Settings for priority order.

Global Settings

The following settings can only be set in the global ~/.posit/assistant/settings.json. They are not supported in project-level config files.

Provider Settings

Provider connection details use a separate global file, ~/.posit/ai/providers.json — they do not go in ~/.posit/assistant/settings.json, the Assistant settings file documented above. In providers.json, configure providers under the providers key. For the full list of supported providers and setup instructions, see Providers.

Credentials are normally set through the application’s settings UI, but you can override the base URL or attach custom HTTP headers in the config file. This is useful for enterprise proxies or custom API gateways that require extra tenancy or routing markers (e.g. Databricks’ x-databricks-use-coding-agent-mode).

{
  "providers": {
    "positai": {
      "baseUrl": "https://my-proxy.example.com",
      "customHeaders": {
        "x-gateway-tenant": "team-42"
      }
    }
  }
}
KeyTypeDefaultDescription
providers.{provider}.baseUrlstringCustom base URL for the provider's API. Some providers require a version segment in the URL: https://api.anthropic.com/v1 for Anthropic, https://api.openai.com/v1 for OpenAI, https://generativelanguage.googleapis.com/v1beta for Gemini — a bare host without it will fail for these providers. Supported by: anthropic, openai, gemini, deepseek, openai-compatible, ms-foundry, snowflake-cortex, and positai.
providers.{provider}.customHeadersobjectExtra HTTP headers attached to every request for this provider. Supported by: anthropic, openai, gemini, openai-compatible, ms-foundry, snowflake-cortex, deepseek, openrouter, and positai. Do not put SDK-managed header names (Authorization, x-api-key, anthropic-version) here.
providers.{provider}.endpointstringLocal endpoint URL for self-hosted providers (ollama, lmstudio). For example, "http://localhost:11434" for Ollama.
providers.allowedProvidersstring[]Restrict which providers are available. If omitted, the platform default is used.
💡 Positron users

In Positron, base URLs and custom headers are stored in Positron’s authentication.* settings. See Positron Settings for details.

📝 Bedrock model endpoints

Bedrock models can use different API paths, so providers.bedrock.baseUrl is not a general redirect. Endpoint selection uses this precedence: providers.bedrock.models.overrides["<model-id>"].baseUrl, then providers.bedrock.endpoints[protocol], then the endpoint discovered for that model, then the provider-wide base URL. Use a model override to redirect one model. A protocol endpoint is appropriate when all models on that protocol share a path, such as openai-chat for gpt-oss or openai-responses for GPT-5.x. The Anthropic Messages and Converse routes use their AWS SDK endpoints.

Custom Providers

On Node-backed surfaces — Standalone, Desktop, RStudio, and the Terminal (TUI) — you can declare your own providers under the providers.custom key in ~/.posit/ai/providers.json. Each entry is keyed by a name of your choosing — the key is used as the provider’s display name — and declares its behavior with a type field. Positron does not currently expose custom providers; use its built-in provider configuration instead.

{
  "providers": {
    "custom": {
      "acme-ai": {
        "type": "openai-compatible",
        "baseUrl": "https://ai-gateway.acme.com"
      }
    }
  }
}

Supported type values: openai-compatible, aws, snowflake, google-vertex, ollama, lmstudio, deepseek, openrouter, and ms-foundry.

Storage Settings

KeyTypeDefaultDescription
storage.pathstring"~/.posit/assistant"Directory for conversation storage.

Logging

KeyTypeDefaultDescription
logging.levelstring"info"Log level. Options: "error", "warn", "info", "debug", "trace".
logging.filestring""Log file path. Defaults to ~/.posit/assistant/logs/{platform}.log.
logging.consolebooleantrueOutput logs to the console.

Example Configuration

{
  "model": {
    "provider": "positai",
    "id": "claude-sonnet-4-6"
  },
  "permission": {
    "read": "allow",
    "bash": {
      "git *": "allow"
    },
    "task": {
      "explore": "deny",
      "general": "ask"
    }
  },
  "skills": {
    "paths": [
      "~/.agents/skills",
      "~/.posit/assistant/skills",
      ".agents/skills",
      ".posit/assistant/skills",
      "~/my-company/shared-skills"
    ]
  }
}
📝 Changes take effect on restart

Some configuration changes require restarting the assistant or opening a new conversation to take effect.

Developer Settings

No stability guarantees

The settings in this section are experimental or developer-facing. They may change, break, or be removed between releases without notice. Use them at your own risk. Documentation here may lag behind the actual behavior.

These settings go in the features block of your config file and can be set at either global or project level. For example:

{
  "features": {
    "experimentalFeatures": true,
    "cacheKeepaliveWidget": true
  }
}
KeyTypeDefaultDescription
features.experimentalFeaturesbooleanfalseEnable experimental in-development features. Gates access to new capabilities that are still being refined, including the plugin & marketplace manager and its /plugin and /marketplace commands.
features.devModebooleanfalseEnable developer debugging surfaces such as raw tool data display, conversation path copying, and dev-only commands.
features.enablePersonaSelectorbooleanfalseShow the persona selector in the status bar, allowing you to switch between additional assistant personas.
features.cacheKeepaliveWidgetbooleanfalseShow a status-bar widget that displays cache warmth, a countdown to the next ping, and controls to extend, reduce, or stop the idle ping chain. Requires cache keepalive to be enabled.
💡 Positron users

These settings also exist as Positron VS Code settings (assistant.experimentalFeatures, assistant.devMode, assistant.enablePersonaSelector, and assistant.cacheKeepaliveWidget). They are not exposed in the Settings UI — edit settings.json directly. When set in both places, Positron merges them; see Positron Settings for priority order.

Environment Variables

Some settings can also be controlled via environment variables. Environment variables take precedence over file-based configuration. See Providers for the full list of provider environment variables.