Transparency and approvals

What this accomplishes

The option matrix (decision cards), the plan review card, Specialist team approval, the Specialists dashboard, and the cost and time ceilings that auto-cancel when tripped.

Before a non-trivial change, the agent shows its options and waits for your choice. While it runs — and while sub-agents run — you can see tool calls, progress, and cost.

This guide covers transparency and approvals. Plan-only work is in plan mode; sub-agents are in sub-agents; spend is in cost and budget.

Current availability

This page documents behaviour verified in Miton development builds. Miton is still pre-release and is not publicly downloadable; invited beta users will receive a signed desktop build with automatic updates.

Before you start

• A Miton development build and an active project containing source code.
• A connected model. Trust the project before allowing file, terminal or Git actions.

The option matrix

When the agent’s turn ends in a clarifying question that carries two or more distinct paths forward, Miton renders decision cards (the option matrix) instead of plain question text. One option falls back to ordinary text; two or more render the matrix.

Each option card shows:

The user picks one card, or dismisses the matrix to answer in free text instead.

Plan review

Before a non-trivial change, the agent’s plan lands in Chat as a compact review card — title, state, step count, and a capped summary — with Accept plan, Modify plan, and Decline actions. Opening the card shows the full read-only plan inspector with every step, the architecture notes, and the affected files. See Plan mode for the full review flow.

Specialist team approval

When the agent proposes a temporary Specialist team for a novel objective, the proposal appears in Chat as its own card — the roster, each Specialist’s responsibility, and its resolved model route. No Specialist runs until you Accept team; you can also Remove, Edit, Reduce limits, Request revision, or Cancel team first. See Sub-agents for the full flow.

The Specialists dashboard

The Specialists dashboard shows all running and historical sub-agent and Specialist runs for the current project. It lists each run with:

• Name — the sub-agent’s name (Explorer, Verifier, Debugger, Test Runner, Orchestrator, Researcher, Designer, Analyst, or a Specialist’s role name).
• Status — running, completed, failed, or cancelled.
• Cost and duration — the model cost and elapsed time for the run.
• Provider/model, tokens, and cache — for each delegated run, provider and model, prompt/output tokens, cache reads and writes, cache-hit percentage, output rate, and catalogue-priced cost when available.

The user can cancel a run in progress. There is no pause/resume for a running sub-agent.

The cost and time ceilings

New sub-agent and Specialist runs default to a cost ceiling ($0.10 / $0.50 / $2.00 / unlimited) and a time ceiling (30s / 2min / 10min / unlimited), configurable from the Specialists dashboard. When a running sub-agent crosses either ceiling, Miton cancels that run automatically — there is no pause-and-confirm dialogue to raise or lower the ceiling mid-run.

Session-, day-, or week-level spend limits and alerts are a separate surface — see Cost and budget.

The build receipt

When every step of an accepted plan verifies, Miton shows a final build receipt in Chat. It aggregates the accepted kernel run and every delegated Specialist, and shows the verified step count, route, context, cache-hit percentage, tokens, output speed (tokens/second), and catalogue-priced cost. A failed or stopped Specialist is never counted as complete in the receipt. Per-Specialist detail remains available in the Specialists dashboard.

The agent’s tool calls

The agent’s tool calls are visible in the chat metadata. The user sees every tool call the agent made, the tool’s input, the tool’s output, and the tool’s duration. The user can click a tool call to see the full input and output.

The tool calls are visible in real time. As the agent makes a tool call, the tool call appears in the chat metadata. Stop ends the turn at any point, including mid-tool-call; per-turn rewind (see Git and worktrees) is how you recover the state from before a turn if the agent already made changes.

The tool calls are the audit trail for the agent’s actions. The user can use the tool calls to debug a failure (which tool call failed, what was the tool’s input, what was the tool’s output), to verify a compliance posture (which tools did the agent call, did the agent call any tools it should not have), to document the agent’s behaviour, or to share a session with a collaborator.

What transparency does not cover

Transparency does not cover:

• Model internals — the user sees the agent’s input to the model, the agent’s output from the model, and the agent’s estimated cost. The user does not see the model’s internal reasoning, the model’s hidden state, or the model’s training data.
• Sub-agent internals — the user sees the sub-agent’s session log. The user does not see the sub-agent’s prompt-engineering details, the sub-agent’s retry logic, or the sub-agent’s fallback behaviour.
• Tool internals — the user sees the tool’s input and output. The user does not see the tool’s internal state, the tool’s configuration, or the tool’s dependency graph.

The transparency is at the boundary of the agent’s decision-making. The user sees what the agent does, not how the agent does it. The “how” is in the architecture docs; the “what” is in transparency and approvals.

What success looks like

Transparency is the user-facing surface of the agent’s decision-making. The user sees the agent’s options, the agent’s tool calls, the agent’s sub-agents, and the agent’s cost.

The option matrix, the plan review card, and the Specialist team card are the right shape for a non-trivial change: the agent presents its approach (and alternatives, when there are genuinely distinct paths); the user accepts, edits, or declines before anything runs.

The cost and time ceilings are the user’s guardrail on sub-agent and Specialist spend. Cross a ceiling and Miton cancels that run; there’s no mid-run negotiation.

The Specialists dashboard is the audit trail for sub-agents and Specialists. The user can see every run’s status, tool calls, tokens, cache behaviour, and cost, and can cancel a run in progress.

Common failures and recovery

• Confirm the correct project and branch are active.
• Check the model connection and the permission request shown in Chat.
• Keep the exact error before retrying; use Code troubleshooting when the failure persists.

Related next action

Open Code troubleshooting for recovery steps and diagnostic paths.