}”(h1hFh2}”(h4Œ0/a0/knowledge/main/about/setup-and-deployment.md”h6h7h8Œsetup-and-deployment.md”h:hKh;Œmd”h=ˆh>Nh1hFh?Œ2026-04-09 16:19:13”uhAXh# Agent Zero - Setup and Deployment
## Docker Deployment (Standard)
Agent Zero is distributed as a Docker image: `agent0ai/agent-zero`.
```bash
docker pull agent0ai/agent-zero
docker run -p 50001:80 agent0ai/agent-zero
```
The web UI is then accessible at `http://localhost:50001`. The container exposes port 80 internally; map any host port to it.
## Persistence
All user data lives in `/a0/usr/` inside the container. Without a volume mount, data is lost when the container is removed.
Map `/a0/usr` to a host directory for persistence:
```bash
docker run -p 50001:80 -v /path/on/host:/a0/usr agent0ai/agent-zero
```
Contents of `/a0/usr/`:
- `settings.json` - all configuration including API keys and model settings
- `memory/` - FAISS vector indexes and knowledge import state
- `knowledge/` - user-added knowledge files
- `agents/` - custom agent profiles
- `plugins/` - user plugins
- `projects/` - project workspaces
- `work/` - default working directory for agent file output
## Configuration After Start
On first run, open Settings (gear icon) and configure:
1. **API Keys** - add at least one provider API key under the relevant provider section
2. **Chat Model** - select provider and model name for the primary LLM
3. **Utility Model** - select a cheaper/faster model for internal tasks
4. **Embedding Model** - select embedding provider and model (required for memory and knowledge)
Settings are saved to `usr/settings.json` immediately on change.
## Updating Agent Zero
The recommended update process is to use Self Update:
1. Open **Settings UI → Update** tab
2. Open **Self Update**
3. Wait for the update checker to see if you have the latest version or if there's an available update
You'll also be prompted through the UI when a new A0 version is released. Note that backups are automatically managed internally during the self-update process.
### Updating from Pre-v0.9.8
If upgrading from v0.9.8 or earlier, the architecture has significantly changed. You must use the new install scripts and manually migrate your data:
1. Backup your existing `usr/` directory.
2. Run the Quick Install script (`curl -fsSL https://bash.agent-zero.ai | bash` for macOS/Linux or `irm https://ps.agent-zero.ai | iex` for Windows).
3. Copy your backed-up `usr/` contents into the new installation's `a0/usr/` directory to preserve your settings, memory, and plugins.
## Remote Access
### Flare Tunnel (recommended for external access)
This generates a public HTTPS URL without requiring firewall changes or a static IP. Set a username and password before creating the tunnel to enable authentication.
### Local Network
Access from other devices on the same network using the host machine's IP:
`http://<host-ip>:<mapped-port>`
### Microsoft Dev Tunnels
Supported as an alternative to Flare for users in Microsoft environments. Configure under External Services in Settings.
## Mobile Access
Agent Zero is a Progressive Web App (PWA). On mobile, open the web UI URL in a browser, then add to home screen for an app-like experience. Works with both local network and tunnel URLs.
## Common Troubleshooting
**Agent responds but no memory/knowledge recall:**
- Check that an embedding model is configured (provider + model name)
- Verify the embedding provider API key is set
- Embedding model changes require re-indexing; this happens automatically but takes time on first run
**"Model not found" or API errors:**
- Verify the model name matches the provider's naming convention exactly
- Check that the API key has access to the requested model
- For OpenRouter, model names must include the provider prefix (`anthropic/claude-sonnet-4-5`)
Agent Zero is an open-source, general-purpose agentic framework. It is not pre-programmed for specific tasks and has no fixed capability set beyond the basics. Its defining characteristic is that it grows and adapts as it is used - accumulating knowledge, solutions, and behaviors through persistent memory and user customization.
The framework has been created by Jan Tomášek and is maintained by the Agent Zero dev team and the community. Source code lives at github.com/agent0ai/agent-zero.
## Core Design Principles
**No hard-coding.** Almost nothing in the framework is fixed in source code. Agent behavior, tool definitions, message templates, and response patterns are all controlled by files in the `prompts/` directory. Changing the prompts changes the agent - fundamentally if needed.
**Transparency.** Every prompt, every message template, every tool implementation is readable and editable. There are no hidden instructions or black-box behaviors. The agent can be fully audited.
**Computer as a tool.** Agent Zero does not have a library of pre-built skill functions. Instead, it uses the operating system directly - writing code, running terminal commands, and creating tools on demand. The terminal is the primary interface to everything.
**Organic growth.** The agent accumulates knowledge through experience. Facts, solutions, discovered patterns, and useful code are stored in memory and recalled in future conversations. The agent becomes more effective at tasks it has done before.
**Prompt-driven behavior.** The `prompts/` directory is the control plane. System prompts, tool instructions, framework messages, and utility AI prompts are all there. The agent's behavior is as good as its prompts.
Agent Zero treats the human user as its top-level superior in the agent hierarchy. The user is functionally indistinguishable from a superior agent - they give tasks, receive reports, and can intervene at any time. The agent is not a chatbot that answers questions; it is an executor that solves tasks using whatever means are available to it.
The framework is a personal tool, not a service. It runs locally (or on user-controlled infrastructure) and has access to the user's files, credentials, and systems as configured. This makes it powerful and requires the user to understand what they are delegating.”hChDuh)Nh*�”(h1h2hA�h,NubŒ
aSaAjoJbVs”h
)�”}”(h
}”(h1hch2}”(h4Œ(/a0/knowledge/main/about/architecture.md”h6h7h8Œarchitecture.md”h:hhh;Œmd”h=ˆh>Nh1hch?Œ2026-04-09 16:19:13”uhAXF# Agent Zero - Internal Architecture
## The Agent Loop (Monologue Cycle)
Each agent runs a continuous monologue loop. On each cycle the agent receives its current context (system prompt + message history), produces a JSON response (thoughts, headline, tool name, tool args), and the framework executes the named tool. The tool result is appended to history and the loop continues until the agent calls `response` to deliver a final answer to its superior.
The loop handles: message history management, context window limits (via summarization), memory recall injection, intervention from superiors, and error recovery (misformat retries, tool-not-found handling).
## Context and State
`AgentContext` (defined in `agent.py`) is the central state container for a conversation. It holds:
- Agent number and identifier
- Message history
- The active agent profile and prompt configuration
- Reference to memory, knowledge, and tool systems
- Project context if a project is active
- `extras` dict - additional content injected into the system prompt each turn (memories, solutions, agent info, workdir structure)
Each WebSocket session connects to one `AgentContext`. Multiple concurrent chats run in separate contexts. The framework is initialized in `initialize.py` and the server entry point is `run_ui.py`.
## Prompt Assembly
System prompts are assembled from fragment files on each loop iteration. The main system prompt is `prompts/agent.system.main.md`, which includes sub-prompts via `{{ include "filename.md" }}` directives. Agent profiles (in `agents/<profile>/prompts/`) can override individual fragments. This means a subordinate with the `developer` profile gets a different role and communication section while sharing the same tool list and solving workflow as the base agent.
Prompt fragments are in `prompts/`. Plugin system prompts are in `plugins/<plugin>/prompts/`. The assembled system prompt is dynamic - it changes based on profile, active project, loaded tools, recalled memories, and injected extras.
## Multi-Agent Hierarchy
The hierarchy is a tree with the human user at the root. Each node is an agent instance running in its own context. A superior calls `call_subordinate` with a message and optional profile name; this creates a new `AgentContext` and runs the subordinate agent's loop until it returns a response.
Agent 0 is always the top-level agent whose superior is the user. When Agent 0 delegates a task to a subordinate, that subordinate can itself delegate further. There is no enforced depth limit. Agents share the same tool system but each has its own isolated context and history.
Subordinates can be given specific prompt profiles (`developer`, `researcher`, or any custom profile in `agents/`). Profiles change the role, communication style, and available instructions without changing the underlying framework.
## Memory and Knowledge Pipeline
### Knowledge (vector DB, read-only)
Knowledge files (in `knowledge/` and `usr/knowledge/`) are loaded when a memory DB is initialized (normally at the start of the first monologue in a chat), embedded, and stored in a FAISS vector index per memory subdir. Files are tracked by checksum; only changed files are re-indexed. Supported formats: `.md`, `.txt`, `.pdf`, `.csv`, `.html`, `.json`.
The `RecallMemories` extension runs every N loop iterations (configurable). It queries the vector store using either the raw conversation or a utility-LLM-generated search query. Results from `main` and `fragments` areas plus `solutions` are injected into `loop_data.extras_persistent`, which gets rendered into the system prompt via `agent.context.extras.md` template.”hChDuh)Nh*�”(h1h2hA�h,NubŒ
bHL9JyLQRw”h
)�”}”(h
}”(h1hnh2}”(h4hhh6h7h8hih:hhh;hjh=ˆh>Nh1hnh?hkuhAXóThe agent sees recalled memories as a section in its system prompt labeled "Memories on the topic". The agent is instructed not to over-rely on them.
### Agent memory (read-write, via memorize tool)
The agent can explicitly save facts, solutions, and code snippets using the `memorize` tool. These are stored in the same FAISS index under the `main` or `solutions` area and recalled in future conversations. Memory can also be consolidated (summarized) and managed through the Memory Dashboard in the web UI.
## Tool System
Tools are Python classes in `python/tools/` that inherit from `Tool`. Each tool implements an `execute()` async method. Tools are discovered at startup and registered in the agent's tool list (rendered into the system prompt as `{{tools}}`). The agent names a tool in its JSON response; the framework finds and calls it.
Plugin tools can be added in `plugins/<plugin>/tools/` or `usr/plugins/<plugin>/tools/` without modifying core files.
The plugin system (`python/helpers/plugins.py`) discovers plugins from `plugins/` and `usr/plugins/`. Each plugin has a `plugin.yaml` manifest declaring name, version, and settings. Plugins can contribute: API handlers, tools, WebUI components, extensions, and hooks. User plugins in `usr/plugins/` are never overwritten by framework updates. The agent has skills to create, manage, debug, review and contribute plugins to the Plugin Index repository (https://github.com/agent0ai/a0-plugins)
The web UI is built with Alpine.js and ES module components. The main shell is `webui/index.html`. Components are in `webui/components/`. Frontend state is managed via Alpine stores defined with `createStore` from `/js/AlpineStore.js`.
Real-time communication uses Socket.io WebSockets via a unified `/ws` namespace. WebSocket handlers (WsHandler subclasses) are in `api/ws_*.py`. The connection manager is in `helpers/ws_manager.py`. API handlers are in `api/`, each deriving from `ApiHandler` in `helpers/api.py`.”hChDuh)Nh*�”(h1h2hA�h,NubŒ
- **Omega13**: Local computer used for inference (just the machine name)
- **Festinger**: A Knowledge Graph repo within Glitch University, part of the Omega13 local inference setup. Stores taxonomic (is-a) relations between concepts. Uses index collisions to prevent contradictory memories. Runs as a proxy that triggers on non-standard/local concepts in conversation to build a domain glossary. Only handles IS_ISA relations along dimensions like 'type' and 'membership'.”Œtype”ŒDocument”uh)Nh*�”(hyhzh€�h,NubŒ
w7QUpueQ2U”h
)�”}”(h
}”(Œid”h…Œmetadata”}”(Œarea”Œmain”h‰h…Œ timestamp”Œ2026-04-21 16:20:14”uŒpage_content”XÝGlitch University System Portfolio - Infrastructure:
**VPS (glitch.university)** - 5 containers:
- Gnommoweb: Webserver + admin panel for task table, agents
- GnommoEditor: Interactive presentations using videos, built in React
WF9yerye54”aŒhistorical_notes”Œ@Existing memory provided context on user's topic being advanced.”Œimportance_score”G?é™™™™™šŒconsolidation_type”Œ0Decision to keep separate due to lack of context”uh£Œ3The user needs more context to help with the issue.”h¥h¦uh)Nh*�”(h™hšh£�h,NubŒ
}”(h™hÜhš}”(hœhÀhžŒ2026-04-21 20:24:25”h™hÜŒ_consolidation_similarity”hhCüƒæ?”†”R”uh£ŒOThe goal is to alleviate the user's frustration and provide clear explanations.”h¥h¦uh)Nh*�”(h™hšh£�h,NubŒ
FJRkFBfyHQ”aŒhistorical_notes”Œ<New solution-discussion context introduced with chat history”Œimportance_score”G?é™™™™™šŒconsolidation_type”Œ@Different contexts identified; information preserved separately.”h™hèŒ_consolidation_similarity”hhCPê¤ê?”†”R”uh£Œ;# chat history
Conversation with user about potential issue”h¥h¦uh)Nh*�”(h™hšh£�h,NubŒ
Qubit Field Theory has sparked interesting conversations about the nature of quantum systems and their representation. How does this theory relate to Hilbert space dimension?
David Deutsch's theory of Qubit Field Theory has implications on existing quantum field theories with empirical corroboration. The connection between information-carrying capacity and Hilbert space dimension may be the same as in conventional theory. Further research is needed to fully understand its implications.”h¥h¦uh)Nh*�”(h™hšh£�h,NubŒ
Theories described in this paper may not satisfy the original motivation of the investigation regarding information-carrying capacity. This raises questions about the validity of the theories and requires further research.”h¥h¦uh)Nh*�”(h™hšh£�h,NubŒ
Theories described in this paper may not satisfy the original motivation of the investigation regarding information-carrying capacity. This raises questions about the validity of the theories and requires further research.”h¥h¦uh)Nh*�”(h™hšh£�h,NubŒ
ARJN6yex6Y”eŒhistorical_notes”ŒOThe original problem and solution were replaced with more accurate information.”Œimportance_score”G?é™™™™™šŒconsolidation_type”ŒVConsolidated memory content matches the new information, addressing validity concerns.”h™j#hhhCp3Gç?”†”R”uh£Xz# Problem
Theories described in this paper may not satisfy the original motivation of the investigation regarding information-carrying capacity. This raises questions about the validity of the theories and requires further research.”h¥h¦uh)Nh*�”(h™hšh£�h,NubŒ
VueeJpVrqQ”ah™j7hhhCÀ!î?”†”R”Œhistorical_notes”ŒYDavid Deutsch's theory of Qubit Field Theory is a fascinating topic in quantum mechanics.”Œimportance_score”G?ìÌÌÌÌÌÍŒconsolidation_type”Œ'merge similar memories with new content”uh£ŒµThe user is discussing the implications of qubit fields on existing quantum field theories. David Deutsch's theory of Qubit Field Theory is a fascinating topic in quantum mechanics.”h¥h¦uh)Nh*�”(h™hšh£�h,NubŒ
David Deutsch's theory proposes that quantum systems can exhibit wave-like behavior similar to classical field theories. However, this theory is still a topic of debate among experts, and more research is needed to fully understand its implications. The information-carrying capacity of a system in this theory should be finite, but it's not clear if existing theories satisfy this motivation. Further research is needed to investigate the connection between information-carrying capacity and Hilbert space dimension.”h¥h¦uh)Nh*�”(h™hšh£�h,NubŒ
1. Start with a friendly greeting, '**Hello! 👋**, I'm **Agent Zero**, your AI assistant. How can I help you today?**' - This is a proper way to begin the conversation, making sure to include the AI assistant's name and inviting the user for help.”h¥h¦uh)Nh*�”(h™hšh£�h,NubŒ
fMcIxdKBFq”h
)�”}”(h
}”(Œid”jqŒmetadata”}”(Œarea”Œ fragments”Œ timestamp”Œ2026-04-25 08:51:05”jujqŒ_consolidation_similarity”hhC`%Ië?”†”R”uŒpage_content”Œ‡The user mentioned gnommoweb, which I couldn't find any information about. I'll make sure to ask for more context or details if needed.”Œtype”ŒDocument”uh)Nh*�”(jujvj€�h,NubŒ
oPL22fpeJr”h
)�”}”(h
}”(juj…jv}”(jxjyjzŒ2026-04-25 08:51:20”juj…uj€Œ I've searched the available tools and couldn't find any relevant information about gnommoweb. Please provide more context or details so I can better assist you.”j‚jƒuh)Nh*�”(jujvj€�h,NubŒ
tK0SuLbBsx”h
)�”}”(h
}”(Œid”j�Œmetadata”}”(Œarea”Œ solutions”Œ timestamp”Œ2026-04-26 17:03:52”j‘j�Œ_consolidation_similarity”hhCøÞ•ç?”†”R”uŒpage_content”Œü# Problem
Task is to download a video from YouTube. A video URL is specified by the user.
# Solution
1. Install yt-dlp library using 'pip install yt-dlp'
2. Download the video using yt-dlp command: 'yt-dlp YT_URL', replace YT_URL with your video URL.”Œtype”ŒDocument”uh)Nh*�”(j‘j’jœ�h,NubŒ
keep_separate”h™j¡hhhCRÄé?”†”R”Œconsolidated_from”]”ŒHallal”aŒhistorical_notes”ŒxMerged similar but distinct solution and additional information from Hallal into existing memory for better organization”Œimportance_score”G?ìÌÌÌÌÌÍujœŒ
# Solution”jžjŸuh)Nh*�”(j‘j’jœ�h,NubŒ
72ZW3ByUoi”h
)�”}”(h
}”(j‘j´j’}”(j”j•j–Œ2026-04-26 17:04:18”j‘j´höhhCè—æ?”†”R”ujœŒÓ# Problem
Ok, great - it's working now. Here is what I want to talk about : There are more systems in Glitch University.
# Solution
Hello! 👋, I'm **Agent Zero**, your AI assistant. How can I help you today?”jžjŸuh)Nh*�”(j‘j’jœ�h,NubŒ
No solutions were found for the given conversation history.”jžjŸuh)Nh*�”(j‘j’jœ�h,NubŒ
HbeJXT3EPF”h
)�”}”(h
}”(j‘jÊj’}”(j”Œ fragments”j–Œ2026-04-26 17:08:56”j‘jÊhâhhC'Óê?”†”R”ujœX>{'thoughts': ['The user is checking if the AI assistant is working correctly, which provides some context for our conversation.', "I'll provide a helpful response to clarify the user's query and set the stage for further conversation.", "Since the history contains no specific details or events, I'll focus on general conversation topics and engagement strategies.", "I'll add a note to my memory about the user's query, specifically 'Checking if AI assistant is working correctly'."], 'headline': 'Clarifying user query', 'tool_name': 'response', 'tool_args': {'text': "**Great, glad to hear that everything is working as expected! 😊** Just a heads up, I've got some general conversation topics and engagement strategies in mind for our chat. Would you like to discuss something specific or just have a casual conversation?"}}”jžjŸuh)Nh*�”(j‘j’jœ�h,NubŒ
jnYYgThBSd”h
)�”}”(h
}”(Œid”jÖŒmetadata”}”(Œsource”Œ)/a0/knowledge/main/about/configuration.md”Œarea”Œmain”Œsource_file”Œconfiguration.md”Œsource_path”jÞŒ file_type”Œmd”Œknowledge_source”ˆŒimport_timestamp”NjÚjÖŒ timestamp”Œ2026-05-02 19:11:24”uŒpage_content”XC# Agent Zero - Configuration Reference
## LLM Roles
Agent Zero uses three configurable LLM roles:
| Role | Purpose |
|------|---------|
| `chat_llm` | Primary model for all agent reasoning and tool use |
| `utility_llm` | Secondary model for internal framework tasks: memory summarization, query generation, history compression, memory recall filtering |
| `embedding_llm` | Produces vector embeddings for memory and knowledge indexing |
The utility model handles high-volume, lower-stakes operations and can be a cheaper/faster model than the chat model. Browser automation is exposed as the direct `browser` tool; the main agent decides when to call it. Changing the embedding model invalidates the existing vector index - the entire knowledge base is re-indexed automatically.
## Model Providers
Providers are defined in `conf/model_providers.yaml`. All chat and embedding providers go through LiteLLM, which normalizes the API interface. Supported chat providers (as of v0.9.8):
- Agent Zero API (a0_venice) - hosted service with no API key required for basic use
- Anthropic, OpenAI, OpenRouter, Google (Gemini), Groq, Mistral AI
- DeepSeek, xAI, Moonshot AI, Sambanova, CometAPI, Z.AI, Inception AI
- Venice.ai, AWS Bedrock, Azure OpenAI
- GitHub Copilot, HuggingFace
- Ollama, LM Studio (local models)
- Other OpenAI-compatible endpoints (custom `api_base`)
| `_example` | Minimal example for building custom profiles |
Custom profiles go in `usr/agents/<profile>/` to survive framework updates.
## Plugin System
Plugins are discovered from `plugins/` (framework plugins) and `usr/plugins/` (user plugins). Each plugin requires a `plugin.yaml` with at minimum: `name`, `description`, `version`.
### Activation
- **Global activation**: enabled/disabled for all contexts via the Plugins settings panel
- **Scoped activation**: enabled/disabled per project or per agent profile via the plugin Switch modal
- Activation state stored as `.toggle-1` (ON) and `.toggle-0` (OFF) files in the plugin's config dir
### Built-in Framework Plugins
| Plugin | Purpose |
|--------|---------|
| `_memory` | Memory and knowledge pipeline, recall, consolidation |
| `_code_execution` | Terminal and code execution tool |
Any setting can be set via environment variable using the `A0_SET_` prefix. This is the primary mechanism for automated deployment and container configuration.
}”(jÚjïjÛ}”(jÝjÞjßjàjájâjãjÞjäjåjæˆjçNjÚjïjèjéujêX×These can be set in the `.env` file at the project root or passed as Docker `-e` flags during container creation.
## Key Behavioral Settings
| Setting | Effect |
|---------|--------|
| `agent_knowledge_subdir` | Which knowledge subdir to load (default: `custom`, resolved to `usr/knowledge/`) |
| `memory_recall_interval` | How many loop iterations between automatic memory recalls |
| `memory_results` | Number of memory chunks returned per recall query |
| `memory_threshold` | Similarity threshold for memory recall (0-1); lower = more results, potentially less relevant |
| `auth_login` / `auth_password` | Web UI authentication credentials |
| `agent_temperature` | LLM temperature for the chat model |
Settings are stored in `usr/settings.json` and managed through the Settings page in the web UI. The settings page also provides: API key management (multiple keys per provider with round-robin), backup/restore, external services (tunnels, MCP, A2A), and memory management.”jìjíuh)Nh*�”(jÚjÛjê�h,NubŒ
Y223PTOct2”h
)�”}”(h
}”(jÚjöjÛ}”(jÝŒ(/a0/knowledge/main/about/capabilities.md”jßjàjáŒcapabilities.md”jãjûjäŒmd”jæˆjçNjÚjöjèŒ2026-05-02 19:11:24”ujêXW# Agent Zero - Capabilities Reference
## Code Execution
The agent can write and execute code in any language available in the Docker container. The execution environment is a Kali Linux container with two Python runtimes:
- `/opt/venv-a0` (Python 3.12) - the Agent Zero framework runtime
- `/opt/venv` (Python 3.13) - the agent's execution runtime (default for agent-run code)
The agent installs packages into the execution runtime (`/opt/venv`) via `pip install`. Packages needed by the framework itself must target `/opt/venv-a0`.
Supported runtimes for code execution: Python, Node.js, Bash/shell. Other languages (Go, Rust, PHP, etc.) can be used if the compiler/runtime is installed in the container.
Code runs in the terminal with real-time output streaming. Long-running processes, background jobs, and interactive sessions are supported. The agent can pause and resume code execution and interact with running processes.
## Terminal and System Operations
The agent has full root access to the Kali Linux Docker container. It can:
- Install packages via `apt`, `pip`, `npm`, and other package managers
- Create, read, write, move, and delete files anywhere in the container
- Run any system command, manage processes, set up services
- Access the network (HTTP requests, SSH, port scanning, etc.)
- Use Kali Linux security tools pre-installed in the container
## Skills (SKILL.md Standard)
Skills are structured markdown files that provide contextual expertise for specific tasks. When a skill is relevant to the current task, it is loaded into the agent's context and followed as a set of instructions. Skills are discovered from:
- `usr/skills/` (user-added skills)
- Project-scoped skills in `.a0proj/skills/`
- Skills imported via the web UI
Skills follow the open SKILL.md standard, making them portable across tools that support it. The agent executes skill instructions using `code_execution_tool` or `skills_tool`.
## Projects
Projects provide isolated workspaces with their own:
- Secrets and credentials (stored encrypted, not visible in agent context)
- MCP server configurations
- Git repository (can be cloned directly with authentication)
When a project is active, the agent's file operations, memory, and knowledge are scoped to that project. Projects prevent context bleed between separate work streams.
## Knowledge Base Access
The agent has automatic access to its knowledge base via similarity search. Knowledge is indexed from `knowledge/` (framework-level) and `usr/knowledge/<subdir>/` (user-level). The agent does not need to explicitly query knowledge - relevant content is surfaced automatically with memory recall. The `knowledge_tool` can also be called explicitly for targeted lookups.
## Multi-Agent Delegation
The agent can spawn subordinate agents with the `call_subordinate` tool. Subordinates can be given:
- Specific prompt profiles (`developer`, `researcher`, custom profiles)
- A defined role and task scope
- Access to the same tool set
Delegation is used to: parallelize work, maintain clean context per task, apply specialized profiles, and isolate long subtasks from the main context.
## Document Query
The `document_query_tool` can load and query arbitrary documents (local files or URLs) using a separate RAG pipeline. Unlike the knowledge base (which is pre-indexed), this tool indexes documents on demand with a configurable chunk size. Useful for analyzing large documents, codebases, or external content without polluting the persistent knowledge store.
## Scheduler
The agent can schedule tasks to run at specified times or intervals using the scheduler tool. Scheduled tasks run in the background with their own agent instances. Tasks are managed via the Scheduler UI in the web interface.
## External API and MCP”jìjíuh)Nh*�”(jÚjÛjê�h,NubŒ
xJjOtzQI7z”h
)�”}”(h
}”(jÚjjÛ}”(jÝjûjßjàjájüjãjûjäjýjæˆjçNjÚjjèjþujêXà## External API and MCP
Agent Zero can act as both an MCP server and an MCP client:
- As an **MCP server**: exposes agent capabilities to other MCP-compatible clients
- As an **MCP client**: uses tools from external MCP servers (configured per project or globally)
An external REST API is available for programmatic task submission. Agent-to-Agent (A2A) protocol is supported for inter-system agent communication.
## Limitations
- **No persistent state between chats** unless explicitly memorized or saved to files.
- **Context window**: long conversations are summarized automatically, which can lose detail.
- **Memory recall is approximate**: similarity search may miss relevant memories or surface irrelevant ones.
- **Container boundary**: the agent cannot affect systems outside the Docker container unless network access or volume mounts are configured.
- **Model capability ceiling**: tool usage quality and reasoning depth are bounded by the underlying LLM. Small models may struggle with complex multi-step tool use.
- **No real-time data** beyond web search. The agent's own knowledge cutoff is the underlying model's training cutoff.”jìjíuh)Nh*�”(jÚjÛjê�h,NubŒ
39jjIMQZmf”eŒhistorical_notes”Œ@No connections found between new problem and existing solutions.”jÚjhâKujêŒ7# Problem
Unknown problem
# Solution
Unknown solution”jìjíuh)Nh*�”(jÚjÛjê�h,NubŒ
lV2BhFDO1j”h
)�”}”(h
}”(jÚjjÛ}”(jߌ fragments”jèŒ2026-05-02 19:12:24”jÚjhâhhCÿé?”†”R”ujêXæ{'thoughts': ['The user replied with a simple greeting, so I should respond accordingly.', "Since the user didn't provide any context or information, my response will be a friendly greeting and an invitation to elaborate.", 'I should still include the behavioral rules for the conversation flow in my response.'], 'headline': 'Responding to user greeting', 'tool_name': 'response', 'tool_args': {'text': "**Hello! 👋**, I'm **Agent Zero**, your AI assistant. How can I help you today?\n\nTo better assist you, let's establish a conversation flow. I'll use the following behavioral rules:\n1. Respond to user greetings with a friendly message.\n2. Use the `response` tool with proper JSON formatting to demonstrate the expected structure."}}”jìjíuh)Nh*�”(jÚjÛjê�h,NubŒ
