One agent is usually enough. Until it isn't.
Most of the time I reach for lac agent and it handles whatever I throw at it — read a file, write a function, fix a bug, update the tests. That workflow is fast and I like it. But occasionally I'm looking at a task that's genuinely wide: "add auth middleware, write the tests for it, update the README, and generate the OpenAPI spec." Handing that to a single agent in one shot almost always produces something that's partially right and needs three more rounds of back-and-forth to clean up.
That's exactly the situation /multi was built for.
What /multi actually does
When you run /multi inside a lac agent session, it switches into Multi Agent Mode. Instead of one agent tackling your task top-to-bottom, it splits the work across two to four specialized agents that run in parallel. Each agent gets a focused slice of the problem — one might handle the implementation, another the tests, another the docs. They don't wait on each other.
Once the agents finish their individual pieces, a Project Manager agent steps in. It reads all the output, checks whether it holds together, and decides if the result actually meets the original ask. If something is off — inconsistent naming, a test that doesn't match the implementation, a missing section in the docs — the Project Manager sends feedback and triggers a retry. It'll do this up to three times before surfacing the final synthesized summary to you.
The result you see isn't a raw dump of four agents' outputs stitched together. It's a reviewed, coherent response that went through an internal feedback loop before it reached you.
Running it
First, make sure you have lac-cli installed:
pip install lac-cliOr with the install script:
curl -fsSL https://lacai.io/install.sh | bashStart an agent session and type your task, then switch to multi mode:
lac agent
> /multi add JWT auth to all protected routes, write integration tests, and update the API docsThat's it. You'll see the agents spin up and work through their slices. The Project Manager's review happens automatically in the background — you only see it if there were retries and you want to inspect the reasoning.
The retry loop is the part worth paying attention to
I was skeptical about the Project Manager layer at first. It felt like it would just add latency without adding much. Then I watched it catch a real problem: two agents had used different variable names for the same concept — one called it userId, the other user_id. A single-agent run would have just... shipped that inconsistency. The PM flagged it, the responsible agent fixed it, and the final output was clean.
Three retries sounds like a lot but in practice it almost never hits three. One pass, maybe two. And the time saved debugging the output afterward more than covers the extra seconds of generation.
Undoing a /multi session
This is something I appreciate about how /multi is designed. If you run a big multi-agent task and the result isn't what you wanted, /undo inside a multi session doesn't undo one file at a time — it reverts the entire session at once. Every file the agents touched goes back to where it was before you ran /multi.
Compare that to manually hunting down which files four different agents modified and reverting them individually. No thank you.
When to use /multi vs. regular lac agent
I don't use /multi for everything. For a focused task — fix this function, rename this variable across the codebase, explain what this file does — regular lac agent is faster and has less overhead. The parallel setup costs something, and if your task is genuinely linear you're just paying that cost for no benefit.
Where /multi earns its keep:
- Tasks that have clearly separable concerns — implementation, tests, docs, config — that don't depend on each other being finished first
- Large features where you want a review pass baked in, not bolted on afterward
- Anything where you'd normally break the work into a checklist and tackle it in chunks
A good heuristic: if you'd naturally write a numbered list to describe the work, /multi is probably worth it.
How it fits with the rest of lac-cli
Multi Agent Mode sits alongside the other lac-cli tools rather than replacing them. I'll often use lac shell for quick one-off commands, lac agent for focused coding tasks with PlanMode when I need to think before writing, and /multi when a task is wide enough to split. They're separate tools solving different parts of the same problem, and you can jump between them in the same session.
Project memory in .lac-memory.json also carries across — the agents in a /multi run still have access to whatever context you've built up about your project, so they're not starting cold.
Try it on a real task today
If you've got something in your backlog that you've been putting off because it feels too sprawling to hand off to an AI in one go, that's the perfect test case for /multi. Describe the full scope of what you want done, prefix it with /multi, and watch the agents divide it up. If the result isn't right, /undo puts everything back and you can refine the prompt.
lac-cli is free and open source — grab it from PyPI or check the docs for the full install options.