Rusty IDE
Download

Developer Preview

Coding agents you can actually supervise.

Rusty is a desktop IDE that replaces the single chat window with workflows: research, design, build and verify as separate steps, run end to end or one stage at a time. It picks the workflow for each message and the model for each step, lets a second model curate the context, and records every tool call.

Download for macOSQuickstart

Apple Silicon · macOS 11 or later · Signed & notarized

or install with Homebrew
brew install --cask traian18/rusty/rusty-ide

What makes it different

Built around how agents actually work.

Most tools give you a chat box and hope. Rusty gives you structure, the right model, curated context and a record of everything that happened.

Workflows

A workflow, not a chat window.

A single agent loop decides its own path. A workflow decides it for the agent: which steps run, what each may use, and what must be checked. Rusty ships fifteen of them, from a two-step investigation to an audit, fix and re-audit. Pick one from the Mode menu in Agent Mode, or let Rusty pick for you.

  • Isolated steps. Each agent step runs in a fresh session under its own profile (instructions, tool allow-list and limits) and hands a written summary to the next.
  • Read-only where it should be. Research, Analyze, Plan, Architect, Security and Review cannot edit files at all. Only Build, Refactor, Optimize and Document can.
  • Completion gates. Build cannot report until it has checked its own edits; Plan cannot finish before it has read the code.
  • Plain JSON. The built-in workflows stay read-only, and “Customize a copy” gives you an editable one in your workspace. Workflows and profiles are ordinary files, not hidden state.
How workflows work
The built-in Plan, build, verify workflow in the Behaviors editor. Each step is a node; the inspector sets optional limits.

The catalog

Fifteen workflows, ready when you are.

Six short stages that stop at a result you can read and steer, and nine pipelines that run a whole job. The colors show what each step is allowed to do.

  • Reads only
  • Runs checks, never edits
  • Can change files

Stages6

Short runs that stop at a written result. Read it, correct it, then run the next stage, which builds on it.

  • Research & analyze
    1. Research (reads only)
    2. Analyze (reads only)

    Understand how something works, or compare options, before deciding anything.

  • Architect & plan
    1. Architect (reads only)
    2. Plan (reads only)

    Turn findings into a design, then into an ordered plan.

  • Debug & plan a fix
    1. Debug (runs checks, never edits)
    2. Plan (reads only)

    Find a failure's root cause and plan the smallest fix. Nothing is edited.

  • Security audit & fix plan
    1. Security (reads only)
    2. Plan (reads only)

    Audit a scope and get a remediation plan ordered by severity.

  • Verify & review changes
    1. Verify (runs checks, never edits)
    2. Review (reads only)

    Independently check work that is already done. Nothing is edited.

  • Build & verifycan edit
    1. Build (can change files)
    2. Verify (runs checks, never edits)

    Carry out an approved plan, then have the result checked.

Pipelines9

A whole job from start to finish, run end to end.

  • Plan, build, verifycan edit
    1. Plan (reads only)
    2. Build (can change files)
    3. Verify (runs checks, never edits)

    The everyday default, when the path is clear.

  • Analyze, plan & buildcan edit
    1. Analyze (reads only)
    2. Plan (reads only)
    3. Build (can change files)
    4. Verify (runs checks, never edits)

    Changes to existing code, where understanding it comes first.

  • Research, design & buildcan edit
    1. Research (reads only)
    2. Architect (reads only)
    3. Plan (reads only)
    4. Build (can change files)
    5. Verify (runs checks, never edits)

    Features that rest on unfamiliar libraries, standards or architecture.

  • Fix a bugcan edit
    1. Debug (runs checks, never edits)
    2. Plan (reads only)
    3. Build (can change files)
    4. Verify (runs checks, never edits)

    Reproduce, diagnose, fix and verify a failure.

  • High-risk changecan edit
    1. Analyze (reads only)
    2. Plan (reads only)
    3. Build (can change files)
    4. Verify (runs checks, never edits)
    5. Review (reads only)

    Security-sensitive code, shared utilities and broad changes.

  • Security remediationcan edit
    1. Security (reads only)
    2. Plan (reads only)
    3. Build (can change files)
    4. Verify (runs checks, never edits)
    5. Security (reads only)

    Audit, fix, then re-audit to confirm every finding is resolved.

  • Refactor safelycan edit
    1. Analyze (reads only)
    2. Plan (reads only)
    3. Refactor (can change files)
    4. Verify (runs checks, never edits)
    5. Review (reads only)

    Improve structure without changing behavior.

  • Optimize performancecan edit
    1. Analyze (reads only)
    2. Optimize (can change files)
    3. Verify (runs checks, never edits)

    Measured work: baseline, one change, measure again.

  • Write documentationcan edit
    1. Analyze (reads only)
    2. Document (can change files)
    3. Review (reads only)

    Documentation grounded in the code, checked for accuracy.

Every built-in workflow, step by step

Steer between stages

A long job, one stage at a time.

Each stage ends with a written result. The next workflow you run in the same chat starts from it, so you can read it, correct it in your next message, and only then carry on. Nothing runs past the point you wanted to check.

Auto flows

Don't pick the workflow. Just ask.

Choose Auto and Rusty reads each message and decides: answer directly, or follow the workflow that fits. It reads the conversation too, so “design it” after a research stage goes straight to the design stage, with the findings as its starting point.

  • Confident picks start, risky ones ask. A read-only pick starts straight away and says what it chose. Anything that can change files asks first, and when Rusty is not sure it shows you the likeliest options.
  • Hand over mid-run, if you allow it. Turn on Allow flow switching and, after each step, Rusty checks whether what it found means another workflow fits better. Plan finds a bug? It can hand over to Debug & plan a fix, carrying the finished work along. Otherwise it carries on.
  • You stay in control. Auto never starts an end-to-end pipeline by itself, a switch to a workflow that can change files asks you first, at most two hand-overs happen per message, and Stop ends the turn.
  • Every decision on the record. Each choice appears in Tool Execution Observability, with the request, the probabilities and what it cost.

Uses the same decision model as automatic model selection, so it needs an OpenRouter API key.

Auto flows

Automatic model selection

Every request gets the model it needs.

Stop choosing a model for every message. A decision model called JEV rates each request Light, Standard or Heavy, and Rusty runs it on the model you assigned to that level. Quick questions stay fast and cheap; hard problems get real horsepower.

  • You define the mapping. Any model from any connected provider, reasoning-effort variants included. JEV never sees your model list.
  • Errs on the side of power. When JEV is unsure and leans higher, AUTO steps up one level.
  • A model for each step. In a workflow, each step is rated on its own just before it starts, so Research and Verify can run on a light model and Architect on a heavy one in the same run.
  • More than a router. JEV can also pick between options an agent lays out, and review destructive actions before they run. Both are experimental.

Needs an OpenRouter API key for the decision model. Within a workflow, models switch between steps on the same provider.

Set up AUTO

Smart tools

Let a cheaper model do the reading.

Smart tools are tools the agent calls itself. Instead of pulling a whole file, search or web page into your main model's context, the tool hands it to a separate selector model, one you choose, and returns only what answers the agent's request. Reading bulk text with a cheaper model costs less than doing it with your most expensive one, and your main model works from focused, curated context.

  • The agent calls them, not you. read_file, search_codebase and web_extract are ordinary tools. The executing model describes what it needs, and asks again more specifically if the excerpt is not enough.
  • A different model does the reading. Pick the selector separately from the model running the task, for example a cheaper one with a long context window. It sees the whole file or page and hands back only the relevant parts.
  • Real excerpts, not summaries. Exact lines from files, verbatim quotes from pages with their source URL and headings, and ranked file locations from code search.
  • Cheaper, and accounted for. The bulk is read at the selector's price, not your executing model's, and selector calls are recorded separately in tool observability.

Each tool is opt-in. Choose its selector model once under Settings → Intelligence.

Smart tools
A real smart read_file call. It is recorded as executed by a separate selector model, on its own provider, with each step of the selection.

Tool observability

See exactly what the agent did.

Every tool call is recorded, including which model ran it. When JEV makes a decision, open it to see the request, the probabilities, the confidence and the model it chose, with the raw request and response behind it.

  • A timeline of the run. Follow the agent call by call, and see what it is waiting on.
  • Every decision on the record. The request, the probabilities, the confidence, the model or workflow chosen and what the decision cost.
  • Selector models accounted for. When a smart tool hands the reading to a selector model, the call is recorded as run by that model, with its tokens tracked apart from the main run's.
  • Token Metrics. Daily usage right in the rail, by day, week, month or a custom range.
  • Stays local. Records live in your workspace and are git-ignored automatically.
Observability & metrics
Every run and its calls, with the model that executed each one, the event trace, and per-model token usage.

And the rest

Everything around the agent, too.

Skills

Define how a model works once: system instructions, a preferred model and tool access. Apply it in any chat.

MCP built in

Guided setup for GitHub and Atlassian, plus any MCP server over stdio, HTTP, SSE or WebSocket.

Permission gates

Commands ask before they run, with risk badges and per-session grants. Profiles can allow-list tools and deny risky calls.

Inline Chat

Select code, press ⌘ Enter, and ask about it in place. The conversation stays anchored to the line.

Local by design

Provider keys are encrypted with a key held in the macOS Keychain. Chats and workflows are plain files in your workspace.

Signed and self-updating

A notarized DMG of about 14 MB. Updates are signature-verified and install in place, or use Homebrew.

Rusty Canvas Beta

Plan visually. Execute in bounded steps.

For larger features, turn a brief into an editable graph of tasks. Each task receives only the context you connect to it and writes into an isolated virtual workspace, so you can inspect the files and diffs before they reach your project. Canvas is in beta and still changing.

Rusty Canvas
Boundary · Auth changesGlobal ExplorerFeature brief→ editable task graphTaskSession storeTaskAuth guardTask · runningTestsisolated workspaceContext · brief.mdMCP · docs serverKeep the existingclaims shape.

Get started

Install in a minute.

Then connect a model and open a folder. That is all the setup there is.

Download the DMG

  1. Open the downloaded DMG.
  2. Drag Rusty-IDE into Applications.
  3. Launch it. The app is notarized, so Gatekeeper lets it through.
Download for macOS

macOS 11 Big Sur or later · Apple Silicon

Install with Homebrew

One command installs the app and lets Homebrew keep it current.

brew install --cask traian18/rusty/rusty-ide

Update later with brew upgrade --cask rusty-ide, or from Settings → System inside the app.

Installed? Continue with the Quickstart to connect your first model provider.

Questions

Good to know.

Which platforms does Rusty run on?

macOS on Apple Silicon is the supported build today. The DMG is signed with a Developer ID certificate and notarized by Apple. Windows and Linux packaging exists in the repository, but those builds are not published or verified yet; you can build them from source.

Build from source
Do I need my own model API keys?

Yes. Rusty does not include a model. Connect the providers you already use with a key, or sign in with an existing GitHub Copilot or OpenAI Codex subscription. Claude models work with an Anthropic API key; signing in with a Claude subscription is not supported. Automatic model selection, and Rusty choosing the workflow for you, additionally need an OpenRouter key for their decision model.

Model providers
Where are my chats, keys and workflows stored?

On your machine. Provider keys are encrypted, with the encryption key held in the macOS Keychain. Chats, workflows, profiles and observability records are plain files in a .rusty folder inside your workspace. Model requests go to whichever providers you connect.

Data, storage & privacy
What is the difference between a stage and a pipeline?

A stage is a short run of two steps, usually read-only, that stops at a written result: Research & analyze, for example. A pipeline runs a whole job from start to finish: Fix a bug runs Debug, Plan, Build and Verify. Run a stage, read the result, and the next workflow you run in the same chat builds on it, so you can steer a long job one stage at a time.

Workflows overview
Will Rusty change my files without asking?

Only Build, Refactor, Optimize and Document steps can change files; the other profiles cannot write at all. When Rusty chooses the workflow for you, it never starts one that can change files without asking first, and it asks again before handing a running workflow over to one. Commands an agent wants to run ask before they run.

Permissions & safety
Can I change the built-in workflows or add my own?

The built-in workflows are read-only, so they stay in a known-good state. “Customize a copy” gives you an editable version stored as plain JSON in your workspace, and you can build your own from scratch in the Behaviors editor. A workflow you write can opt in to being chosen by Auto, and can say which workflows it may hand over to.

Profiles & workflows
What does “Developer Preview” mean?

Rusty is under active development. Canvas is marked beta, and features such as risk review and JEV decisions are marked experimental in the app. Expect things to change between releases.

How do updates work?

Rusty checks for updates in the background at startup, and you can check manually under Settings → System. Downloads are verified against a signing key before they install. If you installed with Homebrew, brew upgrade --cask rusty-ide works too.

Updating

Try Rusty on your next task.

Download it, connect a model, and hand it something real.

Download for macOSRead the docs
Esc

Type to search the docs.