Native macOS Shared projects Signed automation

Local execution, durable collaboration

The control plane for local AI work.

Rut is a shared-project workspace for specs, tickets, local execution, and automation. The old CLI-first flow is gone: work is shaped in durable project state, runs locally on the active host, and connects to the rest of your stack through signed inbound endpoints and signed outbound event streams.

Download for macOS Read the docs

Developer ID signed and notarized Local runtime on the active host Signed inbound and outbound webhooks

shared project ticket.create agent.run.done

Project model

Specs and tickets are the source of truth.

Durable project state replaces loose prompt chains and ad hoc local workflow files.

Runtime

Execution stays local to the active host.

Rut owns session lifecycle, while collaborators observe, approve, and request handoff through shared state.

Automation

Public HTTP stays narrow and signed.

Expose work-shaped endpoints and durable event streams without mirroring the private MCP surface.

Execution

No public CLI surface

Rut now runs work through the macOS app and local runtime instead of a CLI-first product story.

Collaboration

Shared projects are the center

Specs, tickets, sessions, receipts, and delivery history all live inside a single durable project scope.

Boundaries

Public automation is work-shaped

Inbound requests create tickets or emit narrow service controls. They do not inject prompts or arbitrary tool calls.

Observability

Durable outbox, receipts, attempts

Outbound events come from canonical project history, with retries, signatures, receipts, and delivery logs.

How Rut works now

Shape the work, run locally, automate deliberately.

The redesign turns Rut into a shared-project system with a clear split between durable state, local execution, and signed automation.

Define specs and durable tickets

Capture the project as shared state instead of ephemeral terminal context. Write specs, stage tickets, attach validation, and keep the plan inspectable for every collaborator.

Let the active host execute the session locally

Runs belong to a local host device, but the shared project keeps the whole team synchronized. Rut exposes canonical ticket and spec tools to local sessions and routes approvals, handoffs, and control intents through shared state.

Wire the project into the rest of your stack

Create inbound endpoints and outbound subscriptions in Settings > Automation, send durable ticket.create requests, and subscribe to signed ticket.* and agent.run.* events.

Architecture

Three surfaces. Clear trust boundaries.

Rut keeps mutable execution local while moving durable collaboration and automation into shared project services.

Shared project state

Specs, tickets, sessions, and journals are durable.

Shared projects hold the canonical workflow model, validation state, approvals, receipts, and event history.

specs tickets approvals

Local runtime

The active host device owns execution.

Rut launches and coordinates sessions locally, then mirrors the durable milestones back into shared project state.

local host handoff control intents

MCP tool surface

Local agents talk to project state through canonical tools.

Ticket and spec mutations stay on the private runtime path through tools such as noded_ticket_* and noded_spec_*.

noded_ticket_list noded_ticket_transition noded_spec_get

Signed automation plane

External systems get a narrow, durable HTTP contract.

Inbound endpoints accept work-shaped requests. Outbound subscriptions emit signed events from the backend outbox.

ticket.create agent.run.done HMAC signatures

Boundary rule: Public HTTP can create durable work and emit host-bound service controls when enabled. It cannot inject prompts, override system instructions, or mirror the private MCP relay.

Platform

Built around the redesigned model.

Rut now reads as a shared-project platform, not a visual wrapper around external CLIs.

Project-shaped work

Specs, tickets, subtasks, validation checks, and approvals all belong to the same canonical project model.

Shared runtime visibility

Collaborators can watch session progress, review durable milestones, and coordinate handoffs without guessing what happened on one machine.

Automation inside the app

Create inbound endpoints, rotate secrets, pause subscriptions, and inspect recent receipts and delivery attempts from Settings.

Host-targeted controls

Interrupt and handoff requests resolve against the active host and lease instead of letting outside systems steer the runtime directly.

Durable event streams

Outbound webhook deliveries come from canonical journals and run lifecycle milestones, with retries and stable event identifiers.

Docs for the real product

The public docs now cover the shared-project model, runtime boundaries, webhook contracts, signatures, and troubleshooting.

Automation

Deploy the public webhook surface, not the private runtime.

Rut exposes project-scoped inbound endpoints, outbound subscriptions, request signing, replay protection, event envelopes, and recent delivery state. Everything is managed from Settings > Automation inside any open shared project.

ticket.create control.interrupt_turn ticket.* agent.run.*

Webhook quickstart Architecture docs

Documentation

Start where the new architecture starts.

The docs are organized around the shared-project model, local runtime, and webhook contracts that now define the product.

Foundation

Run the redesigned platform locally on macOS.

Open a shared project, define specs and tickets, keep execution on the active host, and wire the project into the rest of your stack with signed automation.

Download Rut for Mac

or download the .zip

Signed Notarized Webhook docs included

Requires macOS 14 Sonoma or newer. Universal binary for Apple Silicon and Intel.

Need the contract first? Start with the quickstart.