Permissions
When the active Claude or Codex agent needs to write a file or run a command, a permission card appears inline in the conversation asking you to Allow, Deny, or Always Allow. Always Allow adds the tool to a per-vault allowlist so you’re never asked again for that tool. Allow applies to that one request only; it does not write a permanent rule anywhere. Always Allow is stored only in the per-vault list under Settings → Tools → Always-allowed tools, where you can see and remove it, and nothing is written to the vault’s .claude/settings.local.json.
The card shows a readable summary of what the agent wants to do, with its individual fields in a collapsible Details (N) section, instead of raw truncated JSON. The Agents List, Kanban board, and mobile views show the same summary.
If an agent makes several tool calls or asks several questions at once, the prompts queue per thread: answer the first and the next appears, so none is lost and the thread never waits on a prompt you can’t see.
You can also resolve permissions directly from the Agents List without switching threads.

The default behavior can be changed globally in Settings → Tools → Permission Mode, or per-thread via the shield (🛡) button in the thread footer — a thread-level override takes precedence over the global setting and is useful when you want Plan Mode for one specific task without affecting other threads.
| Mode | Behavior |
|---|---|
default | Use the selected harness’s default permission behavior |
acceptEdits | Automatically accept file edits; prompt for commands and other tools |
bypassPermissions | Skip all permission prompts — the agent executes everything without asking |
plan | The selected harness proposes a written plan before taking any action; you approve, edit, or reject it before it proceeds — see Plan Mode below |
dontAsk | Suppress all interactive permission dialogs; the agent proceeds without confirmation. Intended for scheduled/background sessions that run unattended |
auto | The agent autonomously decides when to prompt vs. proceed based on action risk |
Note for scheduled sessions. Threads created by the built-in scheduler automatically use
dontAskso cron jobs never stall waiting for a permission dialog that nobody is watching. They also inherit any external MCP servers configured under Settings → MCP (Compass, Helio, or any other user-configured HTTP/SSE/stdio server) alongside the plugin’s built-in tools, so scheduled agents have the same tool surface as an interactive session —${VAR_NAME}placeholders in that config are resolved from environment variables and keychain-stored secrets, and a server with an unresolved placeholder is skipped for that run rather than started with a blank credential.
Auto-denied tool calls. In
autoanddontAskmode — or when a deny rule blocks a tool — a tool call can be denied without an interactive prompt. When that happens the conversation shows a distinct “Auto-denied <tool>” annotation, with the deciding reason (e.g.ruleormode), so the denial stays visible instead of only surfacing as a failed tool result.
Cross-project spawn approval
When an agent uses threads_create to start a thread in a different project or working directory than its own, Agent Threads shows a permission card titled Spawn thread in another project. It lists the target project, the working directory, and the first line of the prompt.

Allow creates the thread. Deny creates nothing and returns the error “Cross-project spawn was denied by the user.” to the agent. Always Allow lets later cross-project spawns through without prompting; remove it from the always-allowed tools list in the plugin settings to be asked again. Spawns within the caller’s own project need no approval. See Cross-project spawns for exactly what counts as cross-project.
Codex computer use
Settings → Agent → Codex computer use controls whether Agent Threads makes Codex’s bundled computer-use tools available. It is off by default, including for existing installations without a saved choice. The same setting applies to interactive and scheduled Codex sessions.
When off, Agent Threads supplies a native-app deny policy and disables Codex’s bundled computer-use plugins and the known computer-use MCP entry points. This also disables the shared Codex browser REPL tools. Agent Threads’ own contained browser tools remain available. This setting does not disable arbitrary third-party automation or shell commands.
Turning it on restores the use of your existing Codex configuration; it does not install tools or grant operating-system permissions. Your global Codex configuration is not edited.
Changes take effect when a Codex session starts or restarts, including when it resumes an existing conversation. Already-running or warm sessions retain their previous configuration. Use Reload plugin (safe) when ready to restart them. This control is separate from the permission modes above.
Plan Mode
Set Permission Mode → plan globally in Settings, or use the shield button in the thread footer to set it for a single thread. Claude and Codex can then investigate without mutating files or external state until they produce a plan for your approval. Read-only commands and other non-mutating research are still available.
Codex can also call its no-argument EnterPlanMode control when a task needs investigation before implementation. The current turn hands off at a safe boundary, then Agent Threads starts one fresh native Codex Plan collaboration turn under a read-only sandbox. Claude provides the equivalent transition through its native plan-mode capability.
The flow:
- You send a message as normal.
- A “Planning…” visual state appears while the active agent gathers context without making changes.
- When the agent returns its native structured plan, the existing inline approval card replaces the spinner and shows the full proposed plan text.
- You pick one of three actions on the card:
- Approve — the thread switches back to Default mode before starting one fresh implementation turn.
- Edit — the plan text becomes editable in-place; submitting it switches to Default mode and starts the implementation turn with your revised plan.
- Reject — the card switches to an inline Why are you rejecting this plan? field while the proposed plan stays visible. Type your feedback and press Cmd/Ctrl+Enter to submit (plain Enter adds a newline), or choose Cancel or press Escape to return to the original card without rejecting. The thread stays in or returns to Plan mode and makes no edits; your feedback is sent once to the thread and used for the next revision. If you submit it empty and have no queued feedback, the agent is asked to revise the plan.
Plan Mode is useful for risky or large-scale tasks where you want to review the approach before any files are touched.
Agent questions
When Claude or Codex needs your input before it can continue, Agent Threads shows a persisted question card inline in the conversation. This is the same flow for Claude’s AskUserQuestion and Codex app-server item/tool/requestUserInput requests: the card remains available until you answer it, including after switching threads or reloading the workspace.
Claude questions can offer single-select or multi-select choices plus an Other response. Codex questions preserve their stable IDs and can offer a single-select choice list, Other or free-text input, and masked secret input. Codex questions are always single-select; the plugin does not infer multi-select behavior that Codex did not request.
Codex question cards work natively in Plan mode. In Default mode, they are enabled when the Codex app server advertises default_mode_request_user_input. Older Codex versions remain safe to use, but a Default-mode question may fall back to a prose request instead of an inline card. Update the Codex CLI for the complete experience.
Agent questions are separate from permission cards, which authorize tool actions, and from MCP Elicitation, which collects information requested by an MCP server. Questions asked by a child agent still belong to the owning thread and do not add direct-control capabilities to the Native Agent Workspace.
MCP Elicitation
Some MCP servers need a credential or a form filled before they can proceed — for example, an OAuth flow or a confirmation dialog. When this happens, Agent Threads renders an elicitation card inline in the conversation rather than silently failing.
- URL auth card — displays a clickable link for the OAuth URL. Click it to open the auth page in Obsidian’s Web Viewer (or your system browser), complete the flow, then return to the thread. Claude resumes automatically once the server receives the credential.
- Form card — renders input fields derived from the server’s JSON schema (text fields, selects, checkboxes). Fill in the form and submit; the response is forwarded to the MCP server and the session continues.
Without elicitation support the session would stall indefinitely with no visible feedback. The card makes the situation visible and actionable without leaving Obsidian.