Mothership was one of the main features of our v2 launch, and two days later we pulled it. People have asked me why we'd kill something we just announced, so this write-up is the story of what Mothership was, why it didn't work, and what it turned into. Hopefully it saves you from building the same thing we did.
What Mothership was
Mothership was a proactive layer for Slack, a lot like what Scout is today. You'd add it to Slack channels from the dashboard, and from then on it would watch those channels and get every message, whether or not anyone tagged Replicas. It was basically a Slack automation, except it was always on and prompted by us, so it could reply instantly, answer questions on its own, and spawn workspaces to work on tasks it picked up from the conversation.
It was our answer to the software factory problem. I've written before about how we run our software factory, and the hardest part of it is getting agents to start work without anyone asking. Agents that one-shot changes are already here, but someone still has to notice the bug in Slack and kick off the task. Mothership was supposed to be the thing that noticed, by sitting where the work shows up and starting tasks proactively.
We launched it, and pretty quickly ran into a lot of hurdles.
It was confusing and took too much setup
Mothership lived in the corner of the dashboard, and most people didn't know what to do with it. When you opened it, it showed you that you could add it to Slack channels, set up custom instructions, or pick one of our presets, but it was hard for people to understand what any of that would actually do. You had to make a few decisions before you got anything out of it, and even after setting it up it wasn't obvious why it replied to one message and stayed quiet on another.
It drained the org's credits
We also didn't think about how most people were using Replicas. Most engineers connect their own Claude or Codex subscription, but Mothership was org level, so every message in every channel it watched, from every person on the team, ran on the org's credential. An always-on agent reading every message burns through a subscription very fast, and when it ran out Mothership just stopped answering.
We tried patching it by running DMs on each person's own Claude login, then adding a fallback for Codex, then making DMs opt-in, but each fix was another exception to a model that didn't match how people actually paid for the product.
It was just an automation
The main problem though was that the proactiveness was just a trigger for an automation, and there wasn't really a big difference between the two. A message lands in a channel, an agent runs with a prompt, and maybe it starts a workspace. Everything Mothership achieved proactively could already be done with a Slack-triggered automation.
When we listed what Mothership did that an automation couldn't, there were only two things. It was faster since it was always on, and you didn't need to @ it since it was already reading the channel. Both of those are nice, but they're not a product on their own, and we had built a second and more confusing way to do something our users could already do.
After taking all of this into account, we killed Mothership 2 days after launching it.
What we kept
The two things Mothership did well were worth keeping, since speed and not needing an @ are what make an agent feel like part of the team in Slack. We took those primitives and used them to build Scout, which sits in the channels Replicas is in and replies to follow-ups in its threads without being tagged, and you can raise its proactivity per channel so it answers questions and starts work on its own. I'll write about Scout separately.
The rebirth
The name came back for a different idea. Internally we'd been using a feature called Multitask mode, where one agent splits a task across several workspaces and keeps track of them, and we used it all the time. It was also closer to what we were actually trying to build with Mothership, one place you hand work to that gets it done without you watching every piece.
The old Mothership started from where work comes from and tried to grab it out of Slack. Multitask started from who manages the work once it exists, and that turned out to be the right place to start.
So Motherships today are persistent, long-running workspaces, each one dedicated to an area of your work like billing or onboarding. You talk to one agent and it hands the work to as many ships as it needs, each its own workspace with its own sandbox, while the Mothership keeps its own context lean. A ship isn't done when it opens a PR either, the Mothership follows each one through CI and review fixes and tells you when it's actually ready to merge. It keeps notes on its domain and the decisions you've made, so it knows next month what it learned this week, and it has a board that shows what needs you, what's ready to review, and what's still in progress.
Ships also run as the person who asked for them, with their own coding agent login, GitHub account, and environments, so there's no shared org pool to drain. Slack and Linear are still there, you can give a Mothership its own channel or send it matching Linear tickets, but now they're inputs into something that already makes sense on its own instead of the whole product.
What I'd tell you
If a feature you're building is an existing primitive with a different trigger, it's probably just that primitive, and we should have asked how Mothership was different from an automation before we built a settings page for it. Killing it two days in was cheap compared to months of patching something we didn't believe in, and the parts that worked ended up in a better home.