Can I write my own subagent?

Yes, but you describe it rather than write the definition by hand. Ask ML.ai in plain language, e.g. "Create a subagent that reviews pull requests for security issues," and its bundled create-subagent skill composes a full definition, covering scope, instructions, and allowed tools, written to .opencode/agent/ in your project. You can open and edit that file afterward if it got something wrong.

Why doesn’t my new subagent show up in the @ menu?

Agent definitions are only read at engine startup. Run ML.ai: Restart Engine from the Command Palette after creating one, and it will appear in both the @ picker and Settings → Agents.

Does @explore ever ask for permission?

No. explore is read-only by construction: it searches, greps, globs, and fetches, and cannot edit or write, so there is never an operation for a permission prompt to gate.

If I select general while the session is in Plan mode, does it start editing?

No. general’s own scope (project-only, but able to edit and run commands) sits underneath the session’s standing mode, not above it. A Plan-mode session with general selected still has the edit and write tools denied at the mode layer.

Four subagents, scoped to the job you hand them.

A single general-purpose agent has to be trusted with everything, which means every task carries the blast radius of the riskiest one. ML.ai Code splits the work into four subagents with different scopes, so finding something, designing an approach, and carrying out a change are not the same act.

Install ML.ai Code Book a call

Agents

Choose a subagent for the composer. It stays selected until you remove or replace it.

general

General-purpose agent for self-contained work like edits and refactors.

explore

Read-only exploration: find files, answer architecture questions, leave the tree alone.

architect

Drafts an implementation plan before any code is written.

How it works

Choose a subagent for the composer and it stays selected until you remove or replace it. Each one is built for a different kind of work, and only general carries out changes end to end.

general carries out the work

For a task well defined enough to hand off: a multi-step edit, a refactor, a change you can describe precisely. It edits files and runs commands, but only inside the project, and cannot reach outside the workspace even when the session’s command budget would otherwise allow it. It cannot ask questions mid-task, makes safe, reversible decisions on its own, and hands control back after one turn.

explore finds and explains

A read-only search specialist: it reads files, greps, globs, and fetches, and changes nothing while doing it. Use @explore when you want an answer with zero risk of a side effect, even one you would normally approve without a second thought. Specify how hard it should look, from quick to very thorough.

architect designs the approach

For a change big or unfamiliar enough that the order of work is not obvious. It reads the code and returns the critical files, the trade-offs, and a step-by-step plan. It cannot edit or write anything.

planSubAgent writes the plan down

The same investigation as architect, but the finished plan is written to a markdown file for you to review and approve. It can change nothing except that plan file.

One task, one @-mention

You type

@explore Find every place this repo reads process.env.DATABASE_URL and summarize the pattern.

ML.ai Code routes it

The @-mention sends the request straight to explore, regardless of what mode the session is currently in. explore cannot edit anything while it works, so this is safe to run mid-conversation even in Build mode.

It searches and reports back

explore greps, globs, and reads across the project, then returns a summary of the pattern it found. Nothing on disk changed, and no permission prompt appeared, because there was nothing to approve.

You hand off the real work

For the part that should actually change files, you switch to general or the session’s default agent in Build mode. The investigation and the edit stay two separate, separately-scoped acts.

ML.ai Code

Typing in the composer

@architect design the migration to the new auth flow

general

Carries out a well-defined task end to end.

explore

Searches and explains, changes nothing.

architect

Designs an approach, changes nothing.

planSubAgent

Writes the plan to a file.

Not sent yet · choosing an agent

Worth knowing

A selected subagent stays on the composer until you remove or replace it.
general cannot ask questions mid-task, so give it a task that is already well defined rather than one that needs clarifying.
architect and explore change nothing at all; planSubAgent can write only its own plan file.
A custom subagent you create appears in the menu only after the engine restarts, because agent definitions are read at startup.
Selecting general inside a Plan-mode session does not unlock edits: general’s own project-only scope is a sandbox, not a mode override, so the session’s standing Build or Plan mode still applies underneath it.

Questions worth asking

Plan mode

Plan is genuinely restricted, not a suggestion. The edit and write tools are denied to it, and a stricter command budget applies.

Background runs

A delegated job runs in its own session. Your conversation stays usable, and the run survives the panel being closed, hidden or reloaded.

Try ML.ai Code today, or talk to us about what is next.

Install the editor agent on your own machine, or book a call to talk through your team's workloads.

Install Book a call