Instead of one do-everything assistant, define focused sub-agents, each with its own system prompt, its own curated set of tools, and (optionally) its own model. Your main chat agent can hand work off to them, or you can call them directly over the REST API.
Three things define a sub-agent. Set them once in the Agent Manager and the agent becomes a reusable, callable specialist, from chat or over the API.
Its persona and instructions. This is what makes a research agent behave like a researcher and an extraction agent behave like a parser, the standing brief it carries into every conversation.
Only the tools it is allowed to call, e.g. browser automation tools, template tools, or tools exposed by connected MCP servers. Anything outside the allowlist simply isn't available to that agent.
A specific local or cloud model the agent always runs on. Leave it unset and the agent uses the app default; pin it when a task wants a particular speed, cost, or capability profile.
Each sub-agent runs in its own isolated conversation using the same agentic loop that powers AI Chat; the model reasons, calls tools, reads results, and continues until the task is done. The isolation means one agent's context never bleeds into another's.
It comes down to focus, safety, and cost. A narrow tool grant gives the model fewer ways to go wrong and fewer tokens to spend describing tools it will never use.
Can only search and read. It gathers and summarizes; it can't click, submit, or mutate anything, by construction.
Only gets DOM and table tools. Its whole job is pulling structured data out of a page, so that's all it can reach for.
Pinned to a cheap, fast model. High-volume checks run at a fraction of the cost of a frontier model you'd use for harder work.
Narrow tool grants reduce mistakes and token cost: every tool you don't grant is one the model can't misuse and doesn't pay to keep in context.
Sub-agents are reachable two ways. Use them interactively through your main chat agent, or wire them into anything that can speak HTTP.
Your main chat agent can discover the agents you've defined with list_agents and hand work off to them with chat_with_agent, both exposed as MCP tools. You ask once; it routes the sub-task to the right specialist.
Externally, drive any sub-agent over a plain REST API under /api/ext/agent-manager. Create agents, list grantable tools, and run a conversation, with streaming SSE or a single JSON response. See the endpoint reference below.
Base path /api/ext/agent-manager. Manage the agent roster, inspect the tools you can grant, and run a conversation against any agent.
| Endpoint | Does | Body / notes |
|---|---|---|
GET /agents |
List all defined agents. | - |
POST /agents |
Create an agent. | name*, description, systemPrompt*, tools[], modelRef |
PUT /agents/:id |
Update an existing agent. | Same fields as create. |
DELETE /agents/:id |
Delete an agent. | - |
GET /tools |
List grantable tools, grouped. | Use the returned tool names in tools[] when creating an agent. |
POST /agents/:id/chat |
Run the agent. | message*, images[], stream (default true). Streams SSE events agent.start / agent.delta / agent.done, or returns JSON when stream:false. |
Fields marked * are required. tools[] takes tool names from GET /tools; modelRef is optional and falls back to the app default when omitted.
# Create a Research Agent: own prompt, narrow tool grant.
curl -X POST http://127.0.0.1:8080/api/ext/agent-manager/agents \
-H "Content-Type: application/json" \
-d '{
"name": "Research Agent",
"description": "Searches and reads; never mutates pages.",
"systemPrompt": "You are a focused research assistant. Use only search and read tools. Gather sources, then summarize concisely with citations.",
"tools": ["web.search", "browser.read", "browser.getDom"],
"modelRef": "anthropic/claude-haiku"
}'# Run the agent with a single JSON response (no streaming).
curl -X POST http://127.0.0.1:8080/api/ext/agent-manager/agents/research-agent/chat \
-H "Content-Type: application/json" \
-d '{
"message": "Find three recent benchmarks comparing local LLM inference speeds and summarize them.",
"stream": false
}'
# Omit "stream" (defaults to true) to receive SSE:
# agent.start -> run begins
# agent.delta -> streamed output chunks
# agent.done -> final resultTwo MCP tools let any MCP host, Claude Desktop, other editors and agents, or the in-app agent delegate to your sub-agents. Discover them, then hand work off.
Discover which sub-agents exist so the caller knows who it can delegate to.
Args: none
Returns: agents - a list of { name, description }.
Hand a task to a named sub-agent and get its answer back.
Args: agentName*, message*, images[]
Returns: { agent, response }.
Together these turn your roster of specialists into callable tools: a host or the in-app agent lists the agents, picks the right one, and delegates, without you wiring up anything per-agent.
Define your specialists once, then delegate from chat or drive them over REST and MCP. LumaBrowser is free and runs locally, so your prompts, tools, and models stay on your machine. Want to compose them with other capabilities? Browse the extensions and the full API reference, or start from the overview.