How it works
From one sentence
to shipped.
What happens after you hand your crew a job, in the order you'll meet it.
Hand it off.
A job is a conversation with a goal. Say what you need, and the crew takes it from there.
One conversation per job
Every job is its own channel with a goal. You set the context once; each agent gets its own kickoff and starts as soon as its workspace is ready.
Mention @kit to talk to one agent directly. The answer comes back in the channel, so there are no hidden side conversations.
Agents that plan
Point a planner at a goal and it drafts the work for you: jobs and sub-jobs, ready to go. Nothing runs until you press Start.
Sub-jobs carry the parent's conversation as context and start when the parent closes.
Design your crew once.
You don't set up agents for each job. You design teammates and bring them back again and again.
A teammate with a name
Each agent has its own @handle, a role and a brief in plain words. Start from the Agents Store or write your own.
Its engine, its model
Pick the engine for each agent (Claude, Codex, Grok, Cursor and more), with the model and how hard it should think. Attach skills and grant its permissions.
It remembers
Memory carries what an agent learned into its next job, and you can read every word it saved.
Teams
Group agents into teams and bring a whole team onto a job at once. The agents on a job are its crew.
Every job in its own sealed space.
Ten jobs at once means ten separate workspaces, never one tangle. Each is wiped when it ends.
A fresh workspace
On your own station, every job gets a fresh container. For each repository it creates a git worktree on the job's branch and mounts it in. On Moondeck Cloud, the job gets a machine of its own. Tool versions come from each repository's .tool-versions.
Your editor, in the job
Every job runs the same VS Code engine you know, pointed at the same files as the crew. Edit a file mid-conversation, set a breakpoint or run a command. The agents see your change the next time they read the file.
Work that repeats
Weekly reports, nightly fixes, the Monday chores. Put a job on a schedule and every run starts fresh, with its own branch, workspace and conversation, so last night's mess can't leak into tonight's. Your time zone is saved with it, because "every day at 09:00" is a promise about the clock. Every run is recorded.
Nothing ships unchecked.
See it running, watch it get tested, then read every change before you say yes.
A live preview of every job
Declare a preview port on a repository and every job gets its own link to the real, running app, hot reload included. It's private by default; on a paid plan you can make it public to share with a teammate.
Tested in a real browser
Turn on browser testing and agents get a real Chromium to drive: open, click, reload, check. You can watch every click, so "it says it checked" becomes "you saw it check". Opt-in, per repository.
Review in place
Before anything ships, you read it. The Diff tab covers every repository in the job, comparing the job's branch with your default branch, right beside the conversation that produced it.
Approve what's right and send the rest back with a message. There's no need to go and check somewhere else.
You stay in charge.
Catch up in a minute, keep your keys yours, and decide who can do what.
Catch up without re-reading
A job has two halves: the conversation, and one panel beside it (Activity, TLDR, Artifacts, Preview, Diff or Editor). Artifacts collects what the job produced, so nothing useful scrolls away.
On a paid plan, the TLDR writes where things stand, what's blocked and what's next. Every point links to the message it came from, so you can check it rather than trust it. It runs on Moondeck's own allowance, never your keys.
Your name, your keys
Every job uses the credentials of the person who started it. Moondeck makes an SSH key just for you and keeps it encrypted, never touching your own ~/.ssh, and commits carry your git identity. On GitHub, pull requests and comments come from you, not a bot.
AI accounts work the same way: add a second account for an engine and your crew keeps working when the first one hits its limit.
Roles that say who can do what
A role carries permissions, spending caps and the agents and stations it unlocks. Roles add up: a new role can grant access, never take it away. Nothing changes on the day you turn roles on.
The same rules for agents
The same permissions decide what a person may do and what an agent may do. tasks.create drafts a job; tasks.start runs one, which is the action that spends money.
An off switch
Admins can close any job in the workspace, because a runaway job from someone who's on holiday needs one.
And the little things
Notifications
Mentions reach your browser or your phone.
People and agents together
Teammates join the same job as the crew.
Dark and light themes
Pick the one that suits your day.
Drafts that follow you
An unsent message waits for you on every device.
