The AI in your editor is no longer one assistant that does everything, but a squad you assign work to by role, and that is probably the habit Zoo Code most wants you to pick up.

Most tools for writing code with a model inside an editor share one shape: a single assistant that covers every case. Zoo Code takes another route. It splits the agent into several fixed roles, each with its own boundaries and its own kind of task. Instead of describing a wish to a fuzzy all-rounder, you first decide who this job belongs to and then let that one move.

Its second identity matters just as much. This is the community continuation of Roo Code: the project was maintained by the Roo Code team and later handed to a group of developers who had worked on it, to carry on with the same structure, the same settings and the same licence. For existing users, the old configuration largely travels with them.

An AI development team, fitted into the editor

The product itself is an editor extension, and once enabled it adds a panel to the sidebar. Its signature feature is called Modes, and four roles come built in, each focused on one kind of work.

Code is the everyday default: writing new code, editing files, performing file operations, which covers most ad hoc requests. Architect is the think-first role, and on a complicated change it resists the urge to edit, producing instead a plan document and a map of the files involved so the reasoning can be reviewed before a single line lands. Ask never touches your files, answering questions about the codebase and explaining what a piece of implementation is roughly doing, like a consultant on call. Debug is aimed at problems, chasing a bug, adding logging, isolating the root cause and following it back to the origin.

Beyond those four, custom modes can be defined. A team with a fixed code review process, or a need to produce documents in bulk to a standard, can build a dedicated role and pin down its name, its prompt, the tools it may use and the files it may touch. The phrase AI development team then stops being a metaphor, because you can have the architecture role propose a plan, switch to the coding role to build it, and move to the debugging role when something surfaces along the way, the way you would direct a squad with clear divisions.

Read the diff before anything lands

It does not quietly rewrite your code. Every change is presented as a diff, so you can see exactly what is about to happen before deciding whether to allow it. On a project you do not know well, that matters more than how clever the model is: a change you cannot follow is, in effect, not much different from one that was never made.

Checkpoints come with it. Each step of a task can leave a snapshot behind, so a wrong turn can be walked back instead of watching a pile of files turn unrecognisable. The mechanism ties letting the agent work together with being able to take it back at any moment.

The gate in a long run

Letting an agent run unattended for a long stretch needs a brake somewhere. A later release added a mechanism called Destructive Command Guard: during a long autonomous run it intercepts dangerous commands on its own while letting trusted operations continue, so you are not clicking allow every few seconds. It is designed as an optional protective layer, and once switched on it strikes a balance between safety and peace of mind.

It belongs to the same system as permissions. By default every tool call needs your nod, whether it edits a file, runs a command or reaches an external service. Once you are comfortable, automatic approval can be opened up category by category, so trust is built at a granularity you can live with. What the command line may do and which directories it may reach can also be scoped individually, rather than thrown fully open or fully shut.

Choose any model, but know where the money goes

The extension itself is free and open source, permanently rather than as a trial. It does not carry a model of its own, though, so a reasoning provider has to be attached before it has a brain to work with, and that is the biggest difference from the all-in-one subscription route.

With your own API key you pay only for the provider's usage, and the extension takes no cut. The list of providers it can talk to is long, running from the mainstream commercial models to several regional vendors, and it can also reach models running locally, so code never leaves the internal network. Switching model when a different job calls for it takes a moment, and no single vendor holds you.

For anyone who would rather not manage keys one by one, there is an optional single entry point called Zoo Gateway that gathers the various models behind one endpoint and charges by credits instead of a monthly subscription. It is optional in the plain sense: manage your own keys and you can ignore it entirely.

Moving over from Roo Code

Existing users do not start from zero. Settings can be exported and imported, carrying custom modes, keyboard shortcuts and model configuration along, so familiar habits mostly survive. The repository also holds a note on migrating from Roo Code to Zoo Code, which is meant to be followed once and done.

One caveat: this is closer to a migration than an ordinary version update. The extension's release identity has changed, so anyone with scripts or pipelines calling the extension under its old name has to walk through that part by hand.

Version details live in a public changelog, and the release line keeps moving at the community's own pace. It may not be the most starred project in its category, but as a relay pass it proves at least one thing: as long as people still need the tool, its lifespan does not have to be decided by whether the original author stays.

What Zoo Code sets out to solve is not completing a few lines for you, but having the AI divide the work by role inside the editor while you can still take it back at will. Roles give a task boundaries, diffs and checkpoints make changes reversible, and the guard over destructive commands supplies the brake for long autonomous runs. It is free, open source and not tied to a single model, at the price of paying for your own API usage and being willing to spend a little time learning how the modes work. One real project tells you more than any review.