One agent to manage the rest: Amp's Spaces puts you in the captain's chair, not in the trenches
On November 6 Amp launched Spaces: a space is a conversation with one agent that spawns and coordinates the other agent threads for you. Amp built Spaces itself inside a space, ran a whole feature launch from one, and uses one for weekly security reviews — 16 areas, 14 issues on the first supervised run.

On November 6, the AI coding tool Amp launched a new feature called Spaces. The pitch is simple: a space is a conversation with a single agent whose job is to spawn and coordinate the other agent threads for you. You no longer have to create threads yourself, name them, prioritize them, or watch their progress — that organizing work goes to the lead agent. Amp calls it a "higher-level" way of working with many agents, and the announcement puts it vividly: you sit in the "captain's chair," with a bird's-eye view, diving into the weeds only when you need to, instead of spending all day down in the trenches.
It sounds like marketing, but it points at a real shift. All year, coding agents have gotten more capable and able to do more — and the new work that came with that is managing agents: breaking down tasks, assigning them, waiting for results, merging code, resolving conflicts. One person running five or six threads at once ends up spending the time saved on writing code on being a project manager instead. Spaces is aimed squarely at that bill: if agents can write code, can an agent also manage agents?

1. From managing a pile of threads to talking to one agent
First, what Spaces actually is. It is not a new chat window, and it is not a kanban board. By Amp's official definition, a space is a conversation with a single agent that spawns and coordinates other agent threads on your behalf. You state the goal; it breaks the work down, opens threads, tracks progress, and pulls the results together. Threads are grouped by status in a sidebar, and when you need a deep dive you can click into a single thread and look for yourself.
Starting a space is short: hit the plus in the Spaces section of the sidebar, give it a title, pick a project, and tell the agent what to work on. There is nothing new to configure and no new workflow to memorize. Amp has deliberately kept the bar low, because it wants Spaces to become the default way of working, not a power feature.
The key change is a swap of roles. In the old multi-agent workflow, the human was the coordinator: you decided how to split the work, who got what, and when to merge. In Spaces, the human retreats to the goal layer: you say what you want and what counts as done, and the coordination layer goes to the agent. That is more than a new interface — management itself is being outsourced. Amp's bet is that the ceiling on humans managing agents is low — one person can only track so many threads — while agents managing agents has, in theory, no such ceiling.
One caveat up front: the announcement says nothing about pricing, plan limits, or any cap on how many threads a space can run. Those answers will only come from actually using it. This article does not fill in what Amp left unsaid; it only covers what has been published.
2. Amp used itself as the guinea pig: Spaces v1 was built inside a space
The most convincing part of Spaces is not the feature description but how Amp's own team uses it. According to the announcement, the team had been using Spaces for several weeks before launch — and Spaces itself was built inside a space.
That space was called "Spaces v1," shared by Tim, Lewis, Nicolay, and the rest of the team. They dropped feedback, bugs, and new ideas straight into the chat, and the lead agent delegated them into threads. When teammates wanted to talk something through, they used comments to chat, then tagged in Amp when they were ready. In other words, the space is both a workbench and a meeting room: people talk in it, agents work in it, and neither side has to switch places.
The official screenshot captures this state well: on the left, teammates' feedback and the agent's replies; on the right, a sidebar listing every thread by status — 15 blocked, 4 idle, 1 working, plus 19 inactive in the last 72 hours and 337 archived, with 269 items shipped and 18 open at the top. The picture is worth a long look, because it shows not a clean demo interface but what a real team looks like after weeks of use: lots of threads, messy statuses, all collected in one place.
Why does this "we use it ourselves" detail matter? Because the place multi-agent tools most often break is real team usage: too many messages and it turns chaotic, too many threads and things get lost, agent replies and human discussion blur together. Amp putting its own development process forward as the example shows at least some confidence in the shape. Of course, the Amp team knows its own tool better than anyone, so their smoothness is not a guarantee of yours — more on that later.
3. A whole launch run from one space: Lewis and service accounts
Of the three official examples, the second makes the strongest case: Lewis ran the entire launch of the service accounts feature from one space.
Per the announcement, Lewis rolled out the feature from that space, monitored X, Slack, and bug reports for issues, fixed incoming bugs, and sent emails and refunds to affected users. For the rest of the week, the space kept monitoring user issues and system health. In other words, the most fragmented, easiest-to-drop work of a launch week was pulled into a single conversation.
Why does this example carry more weight than the first? Because the chaos of building a new feature is expected — the team gathers around it anyway. The chaos of launch week is unpredictable by nature, arriving from all sides: users complaining on X, someone pasting an error in Slack, bug reports coming in from everywhere. Even the tidiest workflow falls apart that week. What Lewis's example is meant to prove is that a space can absorb exactly that kind of scattered input: instead of tidying everything into a task list before delegating, you throw the raw feedback in and let the lead agent sort, assign, and follow up.
For vibe coders, this example is more worth copying than the "build a new feature" one. What indie developers lack most is not the ability to write code but the "after-sales bandwidth" of the week after launch: one person fixing bugs, answering users, and watching the service stay up. The old answer was to tough it out, or to avoid shipping anything complicated at all. If a space can genuinely string together "monitor feedback, fix bugs, notify users," what it saves is not a few minutes but the psychological barrier of daring to ship.
But a cold splash is in order: the announcement gives no hard numbers. We do not know how many bugs were handled that week, how many emails were sent, how many refunds were issued, or whether any bug was fixed wrong by the agent and later redone by a human. The example is vivid; the evidence is thin. Treat it as a demonstration of how Spaces can be used, not as a guarantee that it works that way.
4. A weekly security review: 16 areas, 14 issues
The third example is Will's security review, and it has the most concrete numbers of the three. Will gave a space a goal: regularly review recent code changes for security issues. On its first run, the lead agent split the codebase into 16 areas, reviewed each in its own thread, cross-checked every finding in another thread, and kept a summary artifact in the space for Will to review and track.
The announcement also notes a key detail: before it ran for real, the team did a design spike and a supervised first run, which filed 14 issues. In other words, this use of Spaces did not start fully automatic — it was trialed at small scale, judged reliable, and only then handed over to run on a schedule.
This example is the most useful one for vibe coders, for three reasons. First, security review is recurring work, which fits the "give a space a goal and let it run on a schedule" pattern — no need to re-teach it from scratch each time. Second, the process itself suits parallel work: 16 areas that do not interfere with each other, reviewed separately and then cross-checked, beats one person reading top to bottom. Third, and most important, Amp's own team did not hand it over blind: they supervised one run, looked at the quality of the 14 issues, and only then let it run on a schedule. That "supervise first, then let go" rhythm is more worth learning than the feature itself.
Looked at from the other side, the example also reveals an implicit precondition of Spaces: it suits work with clear goals and repeatable processes. A security review has a defined thing to check and a defined output format, which is what lets the lead agent split, assign, and summarize well. If the goal itself is fuzzy — "make this product a bit better" — the threads the lead agent produces will likely be worse than the ones you would split yourself.
5. The same week, the whole industry was answering the same question: with more agents, who manages them?
Spaces was not the only "who manages the agents" news of the first week of November. On November 5, OpenClaw launched Multiplayer, letting several people operate the same agent from two devices and share context, with a shared queue coordinating requests so that instructions do not get lost when everyone uses the agent separately. On November 4, Meta confirmed its acquisition of Conductor, whose product lets developers run multiple coding agents in parallel across workspaces; the same day, OpenAI announced it was acquiring Pierre, folding code storage, browsing, and review tooling into Codex.
All four point in the same direction: once agents go from "one helper" to "a group of colleagues," the bottleneck moves from writing code to coordinating. The difference is the approach: OpenClaw has people share one agent, Meta and OpenAI bought the companies that build coordination tools outright, and Amp has one agent coordinate the rest. Which path works is unknowable today, but the whole industry betting in one direction at once is itself a sign that the problem is real.
For Amp, the timing is both an opportunity and a pressure. The opportunity is that it is the only one of the four to ship "an agent manages agents" as a working product feature, rather than a future plan in an acquisition announcement. The pressure is that once larger tools like Cursor and Claude Code follow with the same idea, how long Spaces' first-mover advantage lasts is an open question. Amp's bet is that the experience of the coordination layer — how threads are grouped, how status is shown, when a human steps in — becomes the new moat, not model capability.
One more angle is worth noting: Meta's Muse launched a feature with the same name, Spaces, around the same time (November 6). The name collision is no coincidence — "space" as a metaphor is becoming an industry consensus: pull people and agents into a bounded place to work. But the two target very different scenes: Muse's Spaces is everyday-life collaboration for general users, while Amp's Spaces is code collaboration for development teams. Same name, different arenas — and for VibeFix readers, the latter is the one that matters.
6. What Spaces means for vibe coding: from "one person plus one agent" to "one person plus a crowd of agents"
The earliest picture of vibe coding was one person plus one agent: you talk, the agent writes, you review. That picture is appealing, but it has a built-in scale limit — one agent can only do one thing at a time. To run things in parallel you open more threads; open more threads and someone has to manage them. Many vibe coders know the actual experience: three threads running at once — one changing the frontend, one fixing tests, one writing docs — and after half an hour, the energy spent remembering which thread is doing what exceeds the energy spent on code. Spaces is aimed at exactly that hidden overhead.
If Spaces really works, the vibe coding workflow shifts from conversational to delegated. You no longer have to split a big goal into a dozen small instructions by hand and feed them to agents one by one; you hand the goal to the lead agent, wait for it to split, assign, and summarize, and then review the result. The unit of review changes too: where you used to review a piece of code, you now review a summary — the work of a dozen threads collected into one report, which you approve or send back. Human work retreats fully from execution to judgment.
But that shift carries a specific warning for indie developers: judgment becomes the only moat left. You used to at least walk through the details while splitting tasks yourself, so you knew roughly how each part was built; in a delegated workflow you drift further from the implementation, and at review time you can only tell whether the result looks right, not whether the process buried a landmine. That is exactly why the security-review example is worth copying: beyond judgment it keeps a second check — one thread's finding gets verified by another thread. Vibe coders using Spaces should keep a similar review mechanism of their own: for critical changes, do not just read the summary, click into the thread and look at the diff; for anything involving money or user data, do not let the agent send it out fully automatically.
There is also a practical lock-in question: Spaces is an Amp feature today, not an industry standard. Once your workflow grows into Spaces, switching tools gets more expensive. Indie developers should factor that in when choosing tools: the better Spaces works, the deeper the lock-in. That is not a reason to avoid it — it is a reason to use it with eyes open. Keep what really matters (requirements, acceptance criteria, review checklists) in your own hands, outside the space, and let the space carry only the execution, not the basis of your judgment.
7. What it does not solve, and three suggestions for vibe coders
Now the part Spaces does not solve — and may even make worse. First, the risk of a single point of misunderstanding: the lead agent is the only coordinator, so if it misunderstands the goal, every thread underneath goes wrong in the same neat way. When you split tasks yourself, one wrong split still leaves the others right; when the lead agent splits wrong, the whole batch can fail together. Centralized coordination means centralized error.
Second, context dilution. The lead agent has to translate your goal into separate instructions for a dozen threads, and every layer of translation loses something. The more threads there are, the further each instruction drifts from what you meant. Amp's answer is that you can click into any thread and dig in — but that pulls you back into managing threads yourself, the very thing Spaces promised to free you from. The "captain only" promise still requires you to come down from the chair when things go wrong.
Third, cost and visibility. The announcement says nothing about how Spaces is billed, nor how many tokens the coordinating agent itself burns. One space running for a week may mean dozens of threads working continuously, and nobody knows what that bill looks like yet. For an indie developer that is not a small thing: however good the feature is, if a week of running it costs as much as hiring a person, you might as well be your own project manager.
With that in mind, three concrete suggestions. First, one space, one job: one feature, one launch, one kind of review — do not throw "the whole project" into a single space. The narrower the goal, the more accurately the lead agent splits it. Second, copy Will's rhythm: supervise a new use once, judge the quality of the results, and only then decide whether to let go — do not go fully automatic on day one. Third, keep human intervention points: like Amp's own team, discuss in comments and tag in Amp only when ready, instead of letting the agent auto-reply all the way through. The value of Spaces is managing less, not managing nothing.
In short: Amp's Spaces hands the job of managing agents to an agent — a key step in coding tools moving from "help you write code" to "help you manage projects." Its three internal examples — building itself, running a whole launch, and a recurring security review — all point to the same use: work with clear goals and repeatable processes is the best fit for a space. Whether it becomes the default way of working is not in the announcement; it is in your own next week. Pick a feature you are already building, open a space, and see after a week whether you feel lighter or busier. And remember the Amp team's own rhythm: supervise one run first, confirm the results are solid, and only then let go — that sentence matters more than any feature description of Spaces.
Comments (0)
Sources
Related articles
On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.
On 11 November 2026, AWS open-sourced UAEF: adapters turn traces from LangGraph, LangChain, Strands and Bedrock AgentCore into one format, then 36 metrics across 7 dimensions score them, flagging regressions past 5%. The judge model is hardened too — scores must cite verbatim evidence, and never decide safety.
On 17 November 2026, Perplexity launched the Orchestrator API: one interface reaching OpenAI, Anthropic, Google, xAI and open-weight models such as GLM, Kimi and DeepSeek, billed at the answering model's published rate with no platform fee. When one provider fails, the same model retries on another deployment, and preview routing assigns requests to models by task.