Before they become implementation tasks.
The problem
AI agents are fast. Your workflow is the bottleneck.
You have Claude Code in one terminal, Codex in another, Gemini helping somewhere else, Cursor in the IDE, and a half-formed product idea sitting in your notes app.
The agents can write the code. The hard part is keeping the work organized.
Rut fixes the part of agent-driven development that still feels manual.
Because context is trapped in chats and terminals.
Unless you are sitting at your desk.
Because decisions are buried in logs.
When one agent needs another to continue the work.
The workspace
Rut is the ticket interface for agent-driven development.
Rut gives every idea, task, agent run, review, note, file, and decision a place to live. Instead of prompting agents one-off and hoping you remember what happened, you move work through a visible system: captured, queued, running, waiting for review, sent back, or done.
This is not another chat window.
It is the operating layer between your ideas and the agents that implement them.
Agent list
Decision inbox
Ticket editor
How Rut works
From idea to implementation without losing the thread.
Capture the idea
Turn product thoughts, bug reports, screenshots, specs, and “we should build this” moments into real tickets.
Capture from desktop or mobile before the idea gets stale.Assign it to an agent
Send the ticket to the agent runtime that makes sense for the job.
Use Claude Code, Codex, Gemini, Cursor, OpenCode, or the local workflow you already trust.Watch the queue move
See what is ready, running, blocked, and waiting for a human decision.
No more guessing which terminal is doing what.Review from anywhere
Approve, reject, redirect, or add context from Mac or mobile.
When an agent needs a decision, Rut brings the decision to you.Keep shipping
Every ticket keeps its context, progress, handoffs, files, and review history.
The next agent does not start from zero. The project remembers.Agents
Give every coding agent a lane.
Your agents should not be fighting for your attention across disconnected terminals. Rut lets you run multiple agent workflows against a shared project model, with visible ownership, status, and handoffs.
Start coordinating your agents
Agents
Codex
Claude Code
Gemini
OpenCode
Managed queue
Ready
In progress
Human review
Done
Delivery
Notes
Attachments
Handoffs
History
Run the right agent for the job
Use Claude Code, Codex, Gemini, Cursor, OpenCode, or whatever agent workflow fits the task.
Queue work instead of prompts
Write the ticket once, attach the context, and let the agent work from a durable source of truth.
See who owns what
Every ticket has state. Every agent has a lane. Every handoff has a trail.
Pause for human review
Route important steps through review before work continues.
Tickets
The missing interface between prompts and pull requests.
Prompts are temporary. Tickets are durable.
Rut turns agent work into structured implementation units with context, progress, notes, files, decisions, and review state. That means agents can pick up work, pause, hand off, and resume without you rebuilding the entire thread every time.
Your agents do better work when the work has a shape.
Specs for intent, constraints, and acceptance criteria.
Tickets for implementation work.
Notes for decisions and progress.
Attachments for screenshots, files, and evidence.
Review states for approval, rejection, and follow-up.
History so every handoff keeps its context.
Mobile
Capture the idea before it dies.
The best implementation ideas rarely happen while you are staring at the terminal. They happen while walking, testing, reading feedback, or using the product.
Rut lets you capture those ideas on mobile and turn them into tickets before they disappear.
Create a ticket the moment the idea appears, with notes, screenshots, files, and context.
See what is queued, running, blocked, waiting for review, or done without opening your laptop.
When an agent needs a human decision, review the request and keep the work moving from your phone.
Mobile is not a separate todo list. It is the same project state your agents use on the Mac.
Human-in-the-loop
Let agents move fast. Keep control of the decisions.
Rut makes human review explicit. When an agent reaches a decision point, it can stop, explain what it needs, and wait for approval.
Approve
Let the agent continue when the plan looks right.
Send back
Ask for changes without losing the ticket context.
Add evidence
Attach screenshots, logs, files, or notes.
Mark done
Close the loop when the work is complete.
Fast agents are useful. Fast agents with a review system are dangerous in the best way.
Workspace
One project model for everything your agents touch.
Rut keeps the messy parts of agent work in one place: active agents, tickets, notes, files, reviews, handoffs, and progress. Instead of chasing context across terminals, chats, docs, and issue trackers, you get a live workspace for implementation.
Rut is where agent work becomes project work.
Automation
Pipe real work into your agent system.
Rut can accept signed inbound work and emit project events back out. That means external systems can create tickets, track progress, and react when agent work changes state.
Use automation to turn alerts, product feedback, internal tools, or custom workflows into durable implementation tickets.
Read automation docs
ticket.create
Create structured work instead of dropping another message in another inbox.
ticket.updated
Subscribe to project events when tickets are created, claimed, changed, reviewed, or completed.
Rut-controlled execution
Automation creates work. Rut keeps execution, review, and agent control inside the app.
Signed delivery
Signed requests, replay-aware delivery, and durable project events make automation safe enough to depend on.
Use cases
Built for developers who have more ideas than terminal windows.
Ship product ideas faster
Capture a feature idea, turn it into a spec, split it into tickets, and send agents to work.
Run parallel implementation tracks
Let different agents explore different tickets without losing ownership or context.
Keep side projects alive
Capture ideas on mobile and keep progress moving when you only have short windows of time.
Review output away from your desk
Approve, redirect, or add context from mobile when work is waiting on you.
Build an agent-driven architecture
Use tickets, shared state, local runtime, webhooks, and review loops to make agents part of a real development system.
Without Rut, agent work is chaos.
Without Rut
- Prompts scattered across terminals.
- Ideas trapped in notes.
- No shared queue.
- No durable handoffs.
- No mobile review.
- No clean way to see what is blocked.
- No project memory after the session ends.
With Rut
- Ideas become tickets.
- Agents get visible lanes.
- Work moves through clear states.
- Reviews happen from Mac or mobile.
- Context survives handoffs.
- Automation can create real work.
- Your agent system keeps moving.
You already have the agents. Rut makes them work like a team.
FAQ
Common questions
Does Rut replace Claude Code, Codex, Gemini, Cursor, or OpenCode?
No. Rut is the workspace around them. You keep using the agents you like. Rut gives them tickets, queues, review states, context, and handoffs.
Why use tickets instead of prompts?
Prompts disappear. Tickets persist. A ticket can hold the goal, context, files, notes, progress, review decisions, and completion history.
Can I run multiple agents at once?
Yes. Rut is designed around multiple agent lanes, so you can see what each agent is working on and where each ticket stands.
What is the mobile app for?
Mobile is for capturing ideas, checking progress, reviewing agent requests, approving work, sending tickets back, and adding context when you are away from your Mac.
Is Rut for solo developers or teams?
Both. Solo developers get a command center for their agents. Teams get a shared project model for coordinating agent-driven work.
Does Rut support automation?
Yes. Rut supports signed inbound work creation and outbound project events, so external systems can create tickets and react to progress.
Download Rut
Turn your AI agents into a delivery system.
Stop managing agent work from memory. Stop losing ideas before they become tickets. Stop wondering what your terminals are doing.
Download Rut, connect your agent workflows, and start shipping from a workspace built for AI-driven implementation.
Mac app for running and coordinating local agent work. Mobile companion for capture, progress, and review.