Find the tool
for the work.
Start with what you want to do, then narrow the list by area or where you use Miton.
All listed features are shown. Turn on JavaScript to filter this catalogue.
Agent runtime and orchestration
The loop that actually runs your agent, plus what happens when a model misbehaves.
Reads your project instructions, all the way up
Miton walks up the directory tree collecting project memory files: its own MITON.md, the open AGENTS.md standard, and the equivalents other agent tools leave behind. It merges what it finds, override siblings included.
Desktop · CLI
Stops the agent looping on the same error
Tool failures get classified against a bundled library of error patterns. Hit the same one twice and a recovery hint goes into the next turn. You still approve any retry, and it can't grant itself a permission.
Desktop · CLI
You get told about conflicts
When two changes collide, Miton stops and shows you both. Last writer doesn't quietly win.
Desktop · CLI
The agent loop is ours
Streaming, cancellation, tool dispatch and context assembly all live in the repository where you can read them. There's no third-party framework sitting between your message and the model.
Desktop · CLI
Teams assembled for one task
Miton can assemble a team of specialists for one task, with its own routing and a bounded dependency graph. When the job's done, the team dissolves.
Desktop · CLI
Drive Claude Code and Codex from Miton
Miton attaches to or launches other agent runtimes, and tells you which of its own guarantees it can't enforce over them. A PTY fallback covers whatever it can't attach to properly.
Desktop · CLI
Predictable context assembly
System prompt, tools, memories, project knowledge, condensed history and your message go in the same order every turn. That's what makes the caching work, and it's what makes a bad turn auditable afterwards.
Desktop · CLI
Long-horizon goals that verify themselves
Set a goal and leave it running. It works locally and in-process under a time cap, checking its own output each round.
Desktop · CLI
Typed hand-off between runtimes
Work moves between runtimes as a typed bundle, and every bundle gets scanned on import.
Desktop · CLI
Errors stop and ask
An unhandled error drops the session into a recovery state and offers you Resume, Edit and Discard. Nothing retries on its own.
Desktop · CLI
Plan, accept, then build
The hand-off from an approved plan to execution is deterministic. What you accepted is what runs.
Desktop · CLI
The right specialist, or none at all
Prompts get matched against each sub-agent's description, and one only fires automatically on a clear win. Pin one with $name, mention one with @name, or leave them out of it.
Desktop · CLI
See which specialist fired and why
Every turn records which model answered, which sub-agent ran and which mode was active. Open it up and you get the full candidate list with confidences.
Desktop
Knows a stalled model from a thinking one
A watchdog resets on every chunk that arrives, heartbeats included. A model gone quiet while it thinks reads differently from one that's stopped sending bytes at all, so a hung provider costs you seconds.
Desktop · CLI
Per-turn control of the model
Temperature, token ceiling, reasoning effort, memory injection and session instructions are all adjustable on the turn you're about to send.
Desktop · CLI
Sub-agent graphs can't run away
Depth and fan-out are hard-capped, and cancelling a parent cancels everything under it. There's no setting that would let a graph fork-bomb your machine.
Desktop · CLI
Sub-agent output gets reviewed
Results come back summarised and reviewed, so a sub-agent's full transcript never lands in your context.
Desktop · CLI
Sub-agents in isolated worktrees
Parallel agents each get their own git worktree, so your checkout stays untouched. Review what they did, then merge or discard.
Desktop · CLI
Reasoning stays visible without taking over
Model thinking sits in a compact strip you can open when you want it.
Desktop
Picks up where you left off
Last session, last action, project phase, open milestones and test status ride into every new session on a compact card. You stop re-explaining your own project every morning.
Desktop · CLI
Model routing and intelligence
Picking a model for the work at hand, then explaining the pick.
Ranked on what your session actually costs
Real cache-hit and input/output ratios get blended into an effective price per million tokens, and that is the number the ranking sorts on.
Desktop · CLI
Judge the output before you see the badge
Run one prompt through several models with the identities hidden until you've picked a winner.
Desktop
Cheap drafts, expensive critiques
A cheap model drafts, a stronger one critiques and rewrites, and the whole thing is orchestrated on your machine. You get better work than the cheap model manages alone for less than starting the strong one from scratch.
Desktop · CLI
A sensible default, from your own data
Your starting routing profile is recommended from real signals, so it's already close before you touch it.
Desktop · CLI
Stops a model burning money mid-turn
Cost blow-ups, cache-miss storms and repeated tool-validation failures can abort a turn and re-route it while it's still running.
Desktop · CLI
Routing changes have to prove themselves
Routing and condensation decisions replay deterministically against a regression bank, wired into the build.
Desktop · CLI
Fallbacks that learn from your work
Per-category fallback chains get rebuilt from your own session history. Models that keep failing your debugging sessions stop being offered for debugging.
Desktop · CLI
A panel of models when it's worth it
Miton offers multi-model comparison for research, planning and architecture decisions. Restricted and local-only postures keep it switched off.
Desktop
Fast task classification
A sub-millisecond heuristic handles most prompts, with a local embedding pass behind it for the ones it's unsure about. The slow model-based pass ships off by default.
Desktop · CLI
Completions route separately
Inline completions get their own fast path, so they're never competing with your conversation for the strong model.
Desktop
Routing never leaves your machine
The router is a local library and makes no network call. Your model choices stay yours.
Desktop · CLI
Routing telemetry stays on disk
The record that makes routing smarter is a local file. Nothing uploads it, and you can wipe it whenever you like.
Desktop · CLI
Named model groups
Build allowlists like 'local only' or 'cheap coding' and switch one on globally. Scoring then happens inside the pool you chose.
Desktop · CLI
Chronically unreliable models get demoted
Success rate, stalls, speed and freshness roll into a health score for each model, warmed up from your own recent history. You find out a provider is degraded from your own experience, well before a status page says so.
Desktop · CLI
Per-model protocol facts
Wire dialects and tool-calling quirks are recorded per model, so adapters stop guessing at what a provider will accept.
Desktop · CLI
One hop, not two
If your provider is already a router, Miton spots it and targets the underlying model directly.
Desktop · CLI
Smarter in your language
Non-English prompts score against the multilingual dimension, so routing quality is judged per locale.
Desktop · CLI
Routing decisions are cached
Repeated work reuses the decision it already made.
Desktop · CLI
Every routing choice explains itself
The chosen model arrives with the cost, capability and policy signals that picked it.
Desktop · CLI
Five postures, visible weights
Free, Cheapest, Balanced, Premium and Max each show you the quality, cost and speed weights they use, and exactly what changed when you switch.
Desktop · CLI
Quality scores show their working
Each score carries its source, raw measurement, scale, sample count, confidence and retrieval date. A model with no match stays visibly unscored.
Desktop
The model the work deserves
Every task scores against the eligible models on capability, cost and your routing posture. A simple classification goes to a cheap local model; an architecture decision goes somewhere stronger.
Desktop · CLI
The router learns how you phrase things
A small per-workspace model trains on your own prompts, and only overrides the built-in heuristic when it's clearly more confident.
Desktop · CLI
Vision work goes to models that can see
Attachments are checked against the active model's capabilities before a turn goes out.
Desktop · CLI
Token and cost economics
Where your tokens go, and how to stop them going there.
Tool output is bounded
Tool results get truncated to a budget, and you can see where the truncation happened. One noisy command can't eat your context window.
Desktop · CLI
One budget signal
The routing gate and the cost gate call the same function, so the interface can't tell you 'over budget' in one place and 'fine' in another.
Desktop · CLI
Compare models on real prices
Input, output, cache-read and cache-write prices all get compared together, which often lands somewhere different from the headline figure.
Desktop · CLI
Nothing gets embedded twice
The quick switcher holds off while you're still typing, and the indexer skips chunks that haven't changed.
Desktop
It never drops what you told it
Something you stated in the first turn is still there in the hundredth. It's an invariant with a counter you can watch, and it's covered by tests.
Desktop · CLI
How much room is left
Remaining budget is a first-class value the workspace can act on, and it's on screen while you work.
Desktop · CLI · Mobile companion
Local models get caching too
Cache directives for Ollama, vLLM and llama.cpp. Prompt caching has always been a hosted-model luxury, and its absence bites hardest on exactly the big local models people run for privacy.
Desktop · CLI
Stops paying to read the same thing twice
Opaque payloads become digests and duplicate tool results become back-references, so a file read twice is billed once.
Desktop · CLI
A flat cost curve
Condensation runs after every turn on your small model, so what you send stops growing with the conversation.
Desktop · CLI
Built to hit the provider's cache
System prompt, tools and stated facts sit at the same offsets every turn, so provider caches actually hit. You pay cache-read prices and your first token arrives sooner.
Desktop · CLI
Budget decisions are replayable
The cost engine is pure: no clock, no network, no hidden state. Desktop, terminal and the test harness all reach the same answer, and you can replay any decision it made.
Desktop · CLI
Spend records stay on your machine
What you spent is recorded locally and stays on the device.
Desktop · CLI
Caps that bite before the bill arrives
Budget rules across global, provider, model, project and surface scopes, daily through monthly, each set to warn or block. The most restrictive rule wins.
Desktop · CLI · Mobile companion
Debugging keeps a longer trail than small talk
How much recent history survives condensation scales with the model's window and with the kind of work you're doing.
Desktop · CLI
There's always room for the answer
Prompt plus maximum response is checked against the model's limit before the request goes out.
Desktop · CLI
Memory, knowledge and learning
What Miton remembers. What it learns. What you can delete.
Flags a vague prompt before you send it
Vagueness gets spotted as you type. It's locale-aware, deterministic, and runs without a round trip to anything.
Desktop
It knows what happened last week
Past sessions are synthesised into something short enough to carry forward with you.
Desktop · CLI
Correct it once
Say 'use early returns' or 'no em dashes' once and it holds in later sessions. Confidence decays over time, so a correction you've moved on from fades out.
Desktop · CLI
Keyword and meaning, fused
Recall runs keyword and semantic search together and fuses the two rankings. With the semantic layer unavailable it falls back to keyword and keeps working.
Desktop · CLI
Memory asks first
Decline the first write and you get a store that does nothing at all. Miton starts remembering once you've said yes.
Desktop · CLI
Turn memory off for one session
One toggle isolates sensitive work, and your settings survive it.
Desktop
Memory policies you can swap
Presets like 'redact harder' or 'keep decisions forever'. Plugins can supply their own; those get validated, and redaction is the one thing they're never allowed to loosen.
Desktop · CLI
Old memory ages out
Age-based deletion, then a size cap that removes the oldest entries first. Decisions are pinned by default.
Desktop · CLI
Memory that survives the session
Turns, decisions, tool calls, file operations and test outcomes go into a workspace-scoped database. The agent remembers what it did and how it turned out, as well as what was said.
Desktop · CLI
Memory you can read and edit
Every remembered fact shows its content, when it was written, which session wrote it and how confident it is. Edit or delete any of it and the change takes effect immediately.
Desktop
A prompt library that knows your project
Built-in templates plus a workspace overlay, so your reusable prompts live with the project itself.
Desktop
It offers to remember
When something looks worth keeping, you get asked.
Desktop
Prompt drafting with a small local model
Intent extraction and regeneration under a budget and a stall guard, on a model small enough to be free to run.
Desktop · CLI
Personal data is stripped before it's stored
Redaction runs before the insert and the writer has no way around it. If the redactor is unavailable the write is refused.
Desktop · CLI
Skills proposed from real work
After a substantial task, Miton can propose a reusable skill. Registering it is your call.
Desktop · CLI
Skills as shareable files
Prompts with frontmatter, invoked as slash commands. Write your own and share them with your team as ordinary files.
Desktop · CLI
What you use shapes what gets picked
Skill use feeds back into model selection.
Desktop · CLI
Turns a rough ask into a real prompt
Miton drafts a structured prompt from your own project context and hands back its reasoning, clarifying questions, inferred variables and confidence. You choose whether to use it.
Desktop
Search and code intelligence
Finding things — in your project, and in your own history.
The project as a graph
The layout and model behind a rendering of your project's real topology.
Desktop
Code health from the index
The same index that powers search also feeds a health read on the project.
Desktop
Search that answers with a line number
Keyword and semantic search over your code, fused into one ranking and re-indexed as files change. Ask where the rate-limit middleware is and you get a file and a line.
Desktop · CLI
Diagnostics and completions from a real language server
A language-server bridge with symbol extraction as a fallback.
Desktop
One palette for everything
Command, skill and contextual-action providers behind a single keystroke, with prefixes to narrow the search.
Desktop
Search keeps working without an embedding model
With no embedding model available, the semantic layer stays empty and search falls back to keyword.
Desktop · CLI
Find a setting by typing what it does
The settings surface is indexed, so you can find a control without knowing which panel it lives in.
Desktop
Search your own conversations
Past sessions are indexed and searchable.
Desktop
Project system
The structure that holds a project together as it moves between surfaces.
A topology of your project
Front end, back end, data and infrastructure indexed into a real map, with a recovery path for the front ends that can't be projected.
Desktop
Knows what your project produces
Stack detection and artifact classification, so the project understands its own output.
Desktop · CLI
Canvas hands the back end a brief
Interface work produces a back-end brief and a template hint, so the design carries on past the visual layer.
Desktop
A project map you can read in a diff
Components, relationships, decisions and milestones live in plain markdown, so they review in a pull request and survive being hand-edited.
Desktop · CLI
Scaffolding that matches your stack
Project instructions, rules, README and CI generated for the stack you actually use.
Desktop · CLI
Goals shared across every surface
One source of truth for project outcomes, whether you're in Chat, Canvas, Writer, Automation or Code.
Desktop · CLI · Mobile companion
Notices when your session was painful
Repeated corrections, 'this doesn't work' followed by relief, and files touched again and again without tests all become signals pointing at what to fix.
Desktop · CLI
Milestones that can act
Each milestone can spawn work automatically once its dependencies clear, offer a suggestion, or just sit there staying visible. You pick, per milestone.
Desktop · CLI
Share a project without a server
Project state exports to a file with redaction recorded in the manifest, optional encryption, and byte-identical output for identical state. Imported memory lands in quarantine you accept entry by entry.
Desktop
Notices when the map stops matching the code
Stale blueprints, untested new files, config pointing at files that were deleted, overdue milestones and broken imports. Findings are deduplicated, so a repeat scan stays quiet about what you've already seen.
Desktop · CLI
Fork a session and keep the lineage
Branch a conversation and keep the tree, so the path you didn't take is still there.
Desktop · CLI
The agent proposes edits to its own instructions
When it learns something about your project it offers a diff to the instruction file. You apply it.
Desktop · CLI
Project documentation that regenerates
A documentation skeleton built from the project and kept current as the project moves.
Desktop · CLI
Automation, triggers and runs
Recurring work you can inspect, running on your own machine.
Workflows can wait for a person
An approval node suspends the run until a person resumes it. A webhook can resume it too.
Desktop · CLI · Mobile companion
Test a workflow with no side effects
Run the whole graph against fixtures and see exactly what each node would have done.
Desktop · CLI
A real scheduler on your machine
Cron running locally with missed-fire backfill, so a run skipped while the machine was off catches up when it comes back. Nothing is priced per trigger.
Desktop
A local catalogue for what you install
Workflows, themes, skills, sub-agents, templates and servers, with search, inspect, install and remove.
Desktop
Drive Miton from Telegram or Slack
Opt-in per platform. Every inbound message passes the injection check and every outbound action passes the permission gate.
Desktop
Eighteen node kinds, two of them unusual
Triggers, models, tools, branches, loops, code, sub-agents, HTTP, RSS, email, file watching and git events. Two more advance a project milestone and write to memory, which is how an automation gets to take part in the project it belongs to.
Desktop · CLI
Retry and error policy per node
Configurable backoff and a halt-or-continue choice on every node, set individually.
Desktop · CLI
Replay a single step
History at two levels: the run, and every step inside it with its inputs, outputs, duration and cost. Re-run one step on its own.
Desktop · CLI
Workflows that call workflows
Compose automations out of other automations.
Desktop · CLI
Secrets injected at run time
Credentials resolve when the step executes. They never appear in the saved graph or in run history.
Desktop · CLI
Authenticated webhooks on loopback
Signed webhook delivery bound to your own machine. No public endpoint and no tunnel for local development.
Desktop
Schedules you can drive from a terminal
The same scheduler and run store the desktop uses, reachable headlessly.
Desktop · CLI
A workflow engine with no framework under it
The graph executor has no interface, no desktop and no model provider baked in. Side effects are injected, so every workflow is testable.
Desktop · CLI
Ten workflows that already work
Ten automations that run as they are. Fork one and change what you need.
Desktop · CLI
Safety, permissions and egress
What the agent is allowed to do, and what leaves the machine.
Telemetry is opt-in and scrubbed
A local queue with privacy scrubbing that only sends if you agreed to it.
Desktop · CLI
A blocklist you can add to
Known credential-leak endpoints and secret-hosting paste sites ship built in, and the built-ins stay. A blocked host is never contacted at all, so nothing leaves while you find out.
Desktop · CLI
One ledger for what left the machine
Model, update and integration requests are recorded in a single ledger covering both the interface and native request paths.
Desktop
Check for sensitive information before sending
Outgoing checks look for recognised patterns such as keys, tokens and personal information, including in tool results. They reduce accidental disclosure; they cannot detect every secret.
Desktop · CLI
Four modes, frozen at the start of a run
Read-only, plan, auto-edit and full access. The mode is fixed when a run begins, so nothing escalates quietly halfway through.
Desktop · CLI
Injection checks on the way in
User messages, system prompts and tool results are scanned for prompt injection, including encoded, homoglyph and zero-width payloads.
Desktop · CLI
No agent runs on somebody else's machine
There's no 'run on server' button, no cloud section and no account requirement. Long-horizon work, plugins and sub-agents all run locally, and that's on purpose.
Desktop
Imported material lands in quarantine
Anything arriving from outside is held and scanned, and you accept it entry by entry.
Desktop
A second gate in the native layer
Path and shell checks run at the native boundary as well as in the agent loop. A renderer bug on its own won't get a tool call to your filesystem.
Desktop
Child processes get only what they need
Only allow-listed environment keys cross into a spawned process. Vault-held secrets never do.
Desktop · CLI
Injection detection during the stream
The scan runs while tokens are still arriving.
Desktop · CLI
Untrusted vectors are sanitised
SVG from a model or an import is stripped before it renders.
Desktop
Generated media says so, permanently
Images, audio and video produced by a model carry an always-visible disclosure badge.
Desktop
Traditional Mode, with two profiles
Turn Miton's augmentation down, or all the way off. Miton Traditional fixes routing to one base model and stops the hidden extra model calls, while keeping local memory, indexing, context preparation and recovery hints. Hardcore Traditional pauses the augmentation layer completely, leaving you the model, your files, your tools and your approvals. Safety, credential, trust and approval controls stay on either way, and switching back restores your exact settings.
Desktop
Workspace trust outranks execution mode
An untrusted folder stays restricted even in the most permissive mode. Trust wins, and there are tests holding it there.
Desktop · CLI
Two independent gates
The tool list handed to the model is built from the active mode, so it can't ask for a tool it can't see. Then a separate permission check runs again at dispatch. A bug in one gets caught by the other.
Desktop · CLI
Keys live in the operating system keychain
Credentials and OAuth material are held by the OS, never in a plaintext config file.
Desktop · CLI
Recovery, rewind and orientation
Getting back to where you were after something went wrong.
Every sub-agent, inspectable
Name, status, duration, cost and a link to the log, with pause, resume and cancel.
Desktop
Explains itself at your level
The same suggestion gets phrased three ways depending on how experienced you are: the reasoning for beginners, the filenames for the fluent, one line for experts.
Desktop
Conflicts you can see and resolve
When two surfaces change the same thing you get an explicit conflict panel.
Desktop
The session as a timeline
A visual trail of what happened across a session, laid out in time.
Desktop
A restore point at the moment it crashed
The next launch offers to put you back where you were.
Desktop
Knows when another project needs you
Agents waiting on input, waiting on permission, stalled or crashed surface across every open project.
Desktop · CLI · Mobile companion
Speaks up only when something is stuck
It appears when there's blocked or unfinished work, and stays quiet the rest of the time.
Desktop
Release notes that write themselves
Close a milestone and copy a changelog assembled from the restore points inside it.
Desktop
Two real options, before it acts
When two approaches genuinely differ you get cards with pros, cons, estimated cost and estimated time. It only interrupts when it's actually unsure.
Desktop
One place that answers 'where was I?'
Branch state, uncommitted work, milestones, drift, security findings, spend, running sub-agents and worktrees, all in one view. It ends with a ranked list of what to do next.
Desktop
A restore point after every single turn
Hover any earlier message and restore to that moment, with a preview of exactly which files will change. Snapshots live in your repository, alongside your own commits.
Desktop
Approve the plan task by task
A pre-flight plan you accept or reject one task at a time.
Desktop
A routing log you can open
One keystroke opens the record of how work was routed and what it cost.
Desktop
What rewind can't undo
Rewind restores files. It can't un-send an API call or un-write a row in your database, and the interface says so at the point you use it.
Desktop
Scrub through your session like video
Drag a playhead across restore points, step with the arrow keys, and see a read-only diff at each position without changing anything.
Desktop
A welcome back when you've been away
Come back after a break and get a grouped summary of what happened while you were gone.
Desktop
Keep a snippet through a restore
Highlight something before you rewind and it survives the restore.
Desktop
Suggestions that never send themselves
Context chips drawn from a lot of signal sources, ranked and deduplicated. Clicking one fills the input so you can edit it first.
Desktop
Undo across every surface
One undo history spanning the whole workspace, revertible per action or in a batch.
Desktop
It looks at the interface it just built
When a turn touches interface files, the agent looks at what actually rendered before calling it done.
Desktop
Software delivery
Repositories, review, tests, and everything around shipping code.
Spreadsheets and PDFs, analysed locally
CSV, Excel and PDF ingestion with a sandboxed Python runtime, charts and summary statistics. The data is parsed on your own machine.
Desktop
A browser the agent can use, and you can watch
An in-app browser panel with URL classification and an audit chip, so you can see where the agent went.
Desktop
One interface for GitHub, GitLab and Bitbucket
Repositories, issues, branches, pull requests and checks normalised behind one set of types.
Desktop · CLI
Ghost-text completions in the editor
Inline suggestions as you type, on their own fast routing path.
Desktop
Model Context Protocol, spawned lazily
Servers connect on demand, discovery never auto-trusts, and a sprawling server gets a compact facade so it can't flood your context.
Desktop · CLI
Review a pull request with your chosen models
Review style, security and test coverage with parallel agents. Review context goes to your selected model provider unless you use a local model. Comments pass through injection and sensitive-information checks before posting.
Desktop · CLI
A terminal inside the workspace
Workspace-scoped shell access under the same permission gates as every other tool.
Desktop
Tests run and report back
The agent runs your test suite and reads the result.
Desktop · CLI
Worktrees you can actually manage
Create, review and remove worktrees from the interface, with age and cleanup candidates surfaced.
Desktop
Long-form writing
A proper editor, working citations, and export that holds up.
Cite without leaving the page
Search your references and insert one at the cursor.
Desktop
Citations as a first-class system
Import references, pick a style, and get footnotes and a bibliography that stay in sync and survive export.
Desktop
Export that holds its formatting
Genuine PDF with selectable text, real tables and numbered footnotes, plus Word-compatible and plain formats. There's no print-to-PDF step.
Desktop
Slides out of your document
Long-form work exports to slides as well as documents.
Desktop
Nineteen document starters
From meeting notes and RFCs to a manuscript starter with a book bible, chapter outline and draft chapters, plus a pandas data-analysis notebook. Book and novel requests route there on their own.
Desktop
Suggestions you accept or reject
Every model edit arrives as a tracked change, so nothing gets quietly rewritten in your voice.
Desktop
A real editor
A proper rich-text editor with a slash menu, outline panel, and a live word, character, reading-time and reading-grade bar.
Desktop
Interfaces and publishing
Designing, previewing and shipping something people can visit.
A design floor you can opt out of
New front ends use the kit by default. Imported ones get a read-only alignment check and an explicit choice to realign or keep what you have.
Desktop
Pages ship with their metadata
Per-page metadata, sitemap and robots handled as part of publishing.
Desktop
Bring your Figma variables in
Design variables import directly, so the design system in your file becomes the one in your project.
Desktop
Generate images in the workspace
Image generation with the synthetic-media disclosure attached.
Desktop
See it while it's being built
Changes render as the agent works, against a real preview server.
Desktop
Publish, version, roll back
Every publish is a version and rollback is one action. Custom domains are provisioned properly.
Desktop
Visitor numbers without a tracking industry
Simple visitor counts with short retention, and no ad-tech pipeline bolted onto your project.
Desktop
Models and providers
Connecting models, comparing them, keeping track of what you spend.
Compare what the same work costs
A comparator that spans your providers, so you can see the same work priced several ways.
Desktop
Connect a provider key
Miton does not host inference. Connect your own provider key, or a local model, before the first message.
Desktop
Find a local model that fits
Matchmaker compares local models with your hardware and preferences before you choose what to download. Fit and speed are estimates; a benchmark is a separate real test.
Desktop
Installs the local runtime for you
The runtime as well as the model.
Desktop
What's left on each provider
Balances and quota surfaced where you make the decisions.
Desktop
Watches your providers
Live provider health monitoring feeding a dashboard, so a degraded provider is visible before it wastes your afternoon.
Desktop
Compare models before choosing
Model Finder brings catalogue capabilities, context limits, prices and available scores together. Filter for your task and compare up to four models. A catalogue entry does not connect a provider for you.
Desktop
Everyday quality of life
The small things you notice every single day.
Built to the same standard for everyone
Live-region announcements, contrast checking and a motion system that honours reduced-motion preferences across the whole application.
Desktop · CLI · Mobile companion · Browser console
A career panel
Skills, exposure and direction tracked alongside the work itself.
Desktop
A quick chat that stays a quick chat
A project-independent casual mode for when you just want to ask something. Capability still runs through the same execution mode and permission gates.
Desktop
Everything exports
Chat, sessions, memory and documents all export to open formats. Nothing is trapped.
Desktop
Your own year, in numbers you can share
Favourite model, favourite provider, favourite kind of task, plan progress and free-tier headroom, exportable as a card.
Desktop
Keybindings that match your muscle memory
Presets for the shortcuts you already know.
Desktop
No project picker before you've made anything
Say what you want and Miton opens the right workspace and names a folder from your prompt.
Desktop
Startup and bundle size are budgeted
Performance budgets are enforced in the build.
Desktop
Every project gets its own mark
A generated signature so projects are recognisable at a glance.
Desktop
Take your theme with you
Themes export and import as files.
Desktop
Hosts and reach
Desktop, terminal, phone and browser, all over one shared kernel.
Standalone development in your terminal
Start or resume work, inspect state, run workflows and manage providers from a shell. CLI runs independently of Desktop.
CLI
Use supported Desktop connections
On the same computer, CLI can read compatible provider connections from Desktop. CLI keeps its own projects and sessions.
Desktop · CLI
Headless is still guarded
Workspace trust, permission policy, injection checks, model routing and keychain-held credentials all still apply when there's no window.
CLI
Interactive terminal, or piped output
A terminal interface for people, structured output for programmes, and a plain readline path for CI, SSH and screen readers.
CLI
A desktop application, built as one
Its own shell, agent runtime and project system. It isn't a fork of an editor or a wrapper around someone else's harness.
Desktop
Approve from wherever you are
See what needs a decision and take only the actions your device is permitted to take, checked against policy before they apply.
Mobile companion
Your project on a phone
The companion carries the same conversation, project and attention state. It's a secure projection of your desktop, not a remote desktop and not a second agent.
Mobile companion
Recovers cleanly when the link drops
Direct, remote and offline conditions are each handled explicitly, so you always know whether what you're looking at is current.
Mobile companion
Access verifies offline
A signed assertion checked on your own machine, with a grace window. There's no licence key and no activation server to phone home to.
Desktop · CLI · Mobile companion · Browser console
A browser view of the running desktop
Inspect project state from another screen and take a small, explicit set of actions. Local, read-mostly, desktop-authoritative, with no hosted relay.
Browser console
No features match these filters. Try a shorter search or clear one of the filters.