dev setup, guides, docs

README.md

@@ -3,14 +3,23 @@
 # `Agent Zero`
 
 
-[![Agent Zero Website](https://img.shields.io/badge/Website-agent--zero.ai-0A192F?style=for-the-badge&logo=vercel&logoColor=white)](https://agent-zero.ai) [![Thanks to Sponsors](https://img.shields.io/badge/GitHub%20Sponsors-Thanks%20to%20Sponsors-FF69B4?style=for-the-badge&logo=githubsponsors&logoColor=white)](https://github.com/sponsors/agent0ai) [![Follow on X](https://img.shields.io/badge/X-Follow-000000?style=for-the-badge&logo=x&logoColor=white)](https://x.com/Agent0ai) [![Join our Discord](https://img.shields.io/badge/Discord-Join%20our%20server-5865F2?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/B8KZKNsPpj) [![Subscribe on YouTube](https://img.shields.io/badge/YouTube-Subscribe-red?style=for-the-badge&logo=youtube&logoColor=white)](https://www.youtube.com/@AgentZeroFW) [![Connect on LinkedIn](https://img.shields.io/badge/LinkedIn-Connect-blue?style=for-the-badge&logo=linkedin&logoColor=white)](https://www.linkedin.com/in/jan-tomasek/) [![Follow on Warpcast](https://img.shields.io/badge/Warpcast-Follow-5A32F3?style=for-the-badge)](https://warpcast.com/agent-zero)
+[![Agent Zero Website](https://img.shields.io/badge/Website-agent--zero.ai-0A192F?style=for-the-badge&logo=vercel&logoColor=white)](https://agent-zero.ai) [![Thanks to Sponsors](https://img.shields.io/badge/GitHub%20Sponsors-Thanks%20to%20Sponsors-FF69B4?style=for-the-badge&logo=githubsponsors&logoColor=white)](https://github.com/sponsors/agent0ai) [![Follow on X](https://img.shields.io/badge/X-Follow-000000?style=for-the-badge&logo=x&logoColor=white)](https://x.com/Agent0ai) [![Join our Discord](https://img.shields.io/badge/Discord-Join%20our%20server-5865F2?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/B8KZKNsPpj) [![Subscribe on YouTube](https://img.shields.io/badge/YouTube-Subscribe-red?style=for-the-badge&logo=youtube&logoColor=white)](https://www.youtube.com/@AgentZeroFW) [![Connect on LinkedIn](https://img.shields.io/badge/LinkedIn-Connect-blue?style=for-the-badge&logo=linkedin&logoColor=white)](https://www.linkedin.com/in/jan-tomasek/) [![Follow on Warpcast](https://img.shields.io/badge/Warpcast-Follow-5A32F3?style=for-the-badge)](https://warpcast.com/agent-zero) 
+
+
+## Documentation:
 
 [Introduction](#a-personal-organic-agentic-framework-that-grows-and-learns-with-you) •
 [Installation](./docs/installation.md) •
+[Development](./docs/development.md) •
+[Extensibility](./docs/extensibility.md) •
 [How to update](./docs/installation.md#how-to-update-agent-zero) •
 [Documentation](./docs/README.md) •
 [Usage](./docs/usage.md)
 
+Or see DeepWiki generated documentation:
+
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/agent0ai/agent-zero)
+
 </div>
 
 
@@ -54,7 +63,7 @@ From now on, please use this name for both `git clone` and `docker pull` command
 - Agent Zero uses the operating system as a tool to accomplish its tasks. It has no single-purpose tools pre-programmed. Instead, it can write its own code and use the terminal to create and use its own tools as needed.
 - The only default tools in its arsenal are online search, memory features, communication (with the user and other agents), and code/terminal execution. Everything else is created by the agent itself or can be extended by the user.
 - Tool usage functionality has been developed from scratch to be the most compatible and reliable, even with very small models.
-- **Default Tools:** Agent Zero includes tools like knowledge, webpage content, code execution, and communication.
+- **Default Tools:** Agent Zero includes tools like knowledge, code execution, and communication.
 - **Creating Custom Tools:** Extend Agent Zero's functionality by creating your own custom tools.
 - **Instruments:** Instruments are a new type of tool that allow you to create custom functions and procedures that can be called by Agent Zero.
 

docs/README.md

@@ -4,6 +4,8 @@ To begin with Agent Zero, follow the links below for detailed guides on various
 
 - **[Installation](installation.md):** Set up (or [update](installation.md#how-to-update-agent-zero)) Agent Zero on your system.
 - **[Usage Guide](usage.md):** Explore GUI features and usage scenarios.
+- **[Development](development.md):** Set up a development environment for Agent Zero.
+- **[Extensibility](extensibility.md):** Learn how to create custom extensions for Agent Zero.
 - **[Architecture Overview](architecture.md):** Understand the internal workings of the framework.
 - **[Contributing](contribution.md):** Learn how to contribute to the Agent Zero project.
 - **[Troubleshooting and FAQ](troubleshooting.md):** Find answers to common issues and questions.
@@ -11,7 +13,7 @@ To begin with Agent Zero, follow the links below for detailed guides on various
 ### Your experience with Agent Zero starts now!
 
 - **Download Agent Zero:** Follow the [installation guide](installation.md) to download and run Agent Zero.
-- **Join the Community:** Join the Agent Zero [Skool](https://www.skool.com/agent-zero) or [Discord](https://discord.gg/Z2tun2N3) community to discuss ideas, ask questions, and collaborate with other contributors.
+- **Join the Community:** Join the Agent Zero [Skool](https://www.skool.com/agent-zero) or [Discord](https://discord.gg/B8KZKNsPpj) community to discuss ideas, ask questions, and collaborate with other contributors.
 - **Share your Work:** Share your Agent Zero creations, workflows and discoverings on our [Show and Tell](https://github.com/agent0ai/agent-zero/discussions/categories/show-and-tell) area on GitHub.
 - **Report Issues:** Use the [GitHub issue tracker](https://github.com/agent0ai/agent-zero/issues) to report framework-relative bugs or suggest new features.
 

docs/architecture.md

@@ -119,13 +119,8 @@ Agent Zero comes with a set of built-in tools designed to help agents perform ta
 | call_subordinate | Allows agents to delegate tasks to subordinate agents |
 | code_execution_tool | Allows agents to execute Python, Node.js, and Shell code in the terminal |
 | input | Allows agents to use the keyboard to interact with an active shell |
-| knowledge_tool | Enables agents to retrieve information from memory, knowledge base or online external sources |
 | response_tool | Allows agents to output a response |
 | memory_tool | Enables agents to save, load, delete and forget information from memory |
-| webpage_content_tool | Enables agents to fetch and analyze the text content of webpages |
-
-#### Knowledge Tool
-The `knowledge_tool` uses SearXNG to search the web and retrieve information. It can also search the local knowledge base and memory for relevant information. The tool returns a summary of the information, which can be used by the agent to make decisions or answer questions.
 
 #### SearXNG Integration
 Agent Zero has integrated SearXNG as its primary search tool, replacing the previous knowledge tools (Perplexity and DuckDuckGo). This integration enhances the agent's ability to retrieve information while ensuring user privacy and customization.

docs/contribution.md

@@ -4,6 +4,9 @@ Contributions to improve Agent Zero are very welcome!  This guide outlines how t
 
 ## Getting Started
 
+- See [development](development.md) for instructions on how to set up a development environment.
+- See [extensibility](extensibility.md) for instructions on how to create custom extensions.
+
 1. **Fork the Repository:** Fork the Agent Zero repository on GitHub.
 2. **Clone Your Fork:** Clone your forked repository to your local machine.
 3. **Create a Branch:** Create a new branch for your changes. Use a descriptive name that reflects the purpose of your contribution (e.g., `fix-memory-leak`, `add-search-tool`, `improve-docs`).

docs/development.md

@@ -0,0 +1,143 @@
+# Development manual for Agent Zero
+This guide will show you how to setup a local development environment for Agent Zero in a VS Code compatible IDE, including proper debugger.
+
+> [!WARNING]
+> This guide is for developers and contributors. It assumes you have a basic understanding of how to use Git/GitHub, Docker, IDEs and Python.
+
+> [!NOTE]
+> - Agent Zero runs in a Docker container, this simplifies installation and ensures unified environment and behavior across systems.
+> - Developing and debugging in a container would be complicated though, therefore we use a hybrid approach where the python framework runs on your machine (in VS Code for example) and only connects to a Dockerized instance when it needs to execute code or use other pre-installed functionality like the built-in search engine.
+
+
+## To follow this guide you will need:
+1. VS Code compatible IDE (VS Code, Cursor, Windsurf...)
+2. Python environment (Conda, venv, uv...)
+3. Docker (Docker Desktop, docker-ce...)
+4. (optional) Git/GitHub
+
+> [!NOTE] I will be using clean VS Code, Conda and Docker Desktop in this example on MacOS.
+
+
+## Step 0: Install required software
+- See the list above and install the software required if you don't already have it.
+- You can choose your own variants, but Python, Docker and a VS Code compatible IDE are required.
+- For Python you can choose your environment manager - base Python venv, Conda, uv...
+
+## Step 1: Clone or download the repository
+- Agent Zero is available on GitHub [github.com/agent0ai/agent-zero](https://github.com/agent0ai/agent-zero).
+- You can download the files using a browser and extract or run `git clone https://github.com/agent0ai/agent-zero` in your desired directory.
+
+> [!NOTE] In my case, I used `cd ~/Desktop` and `git clone https://github.com/agent0ai/agent-zero`, so my project folder is `~/Desktop/agent-zero`.
+
+## Step 2: Open project folder in your IDE
+- I will be using plain and clean VS Code for this example to make sure I don't skip any setup part, you can use any of it's variants like Cursor, Windsurf etc.
+- Agent Zero comes with `.vscode` folder that contains basic setup, recommended extensions, and debugger profiles. These will help us a lot.
+
+1. Open your IDE and open the project folder using `File > Open Folder` and select your folder, in my case `~/Desktop/agent-zero`.
+2. You will probably be prompted to trust the directory, confirm that.
+3. You should now have the project open in your IDE
+![VS Code project](res/dev/devinst-1.png)
+
+# Step 3: Prepare your IDE:
+1. Notice the prompt in lower right corner of the screenshot above to install recommended extensions, this comes from the `.vscode/extensions.json` file. It contains Python language support, debugger and error helper, install them by confirming the popup or manually in Extensions tab of your IDE. These are the extensions mentioned:
+```
+usernamehw.errorlens
+ms-python.debugpy
+ms-python.python
+```
+
+Now when you select one of the python files in the project, you should see proper Python syntax highlighting and error detection. It should immediately show some errors, because we did not yet install dependencies.
+![VS Code Python](res/dev/devinst-2.png)
+
+2. Prepare the python environment to run Agent Zero in. (⚠️ This step assumes you have some Python runtime installed.) By clicking the python version in lower right corner (3.13.1 in my example), you should get a list of available environments. You can click the `+ Create Virtual Environment` button. You might be prompted to select the environment manager if you have multiple installed. I have venv and Conda, I will select Conda here. I'm also prompted for desired python version, I will select 3.12, that is known to work well.
+![VS Code Python environments](res/dev/devinst-3.png)
+![VS Code Python environments](res/dev/devinst-4.png)
+
+- Your new environment should be automatically activated. If not, select it in the lower right corner. You might need to open a new terminal in VS Code to reflect the changes with `Terminal > New Terminal` or clicking the `+` button in the terminal tab. Your terminal prompt should now start with your environment name/path, in my case `(/Users/frdel/Desktop/agent-zero/.conda)` This shows the environment is active in the terminal.
+
+![VS Code env terminal](res/dev/devinst-5.png)
+
+3. Install dependencies. Run these two commands in the terminal:
+```bash
+pip install -r requirements.txt
+playwright install chromium
+``` 
+These will install all the python packages and browser binaries for playwright (browser agent).
+Errors in the code editor caused by missing packages should now be gone. If not, try reloading the window.
+
+
+## Step 4: Run Agent Zero in the IDE
+Great work! Now you should be able to run Agent Zero from your IDE including real-time debugging.
+It will not be able to do code execution and few other features requiring the Docker container just yet, but most of the framework will already work.
+
+1. The project is pre-configured for debugging. Go to Debugging tab, select "run_ui.py" and click the green play button (or press F5 by default). The configuration can be found at `.vscode/launch.json`.
+
+![VS Code debugging](res/dev/devinst-6.png)
+
+The framework will run at the default port 5000. If you open `http://localhost:5000` in your browser and see `ERR_EMPTY_RESPONSE`, don't panic, you may need to select another port like I did for some reason. If you need to change the defaut port, you can add `"--port=5555"` to the args in the `.vscode/launch.json` file or you can create a `.env` file in the root directory and set the `WEB_UI_PORT` variable to the desired port.
+
+It may take a while the first time. You should see output like the screenshot below. The RFC error is ok for now as we did not yet connect our local development to another instance in docker.
+![First run](res/dev/devinst-7.png)
+
+
+After inserting my API key in settings, my Agent Zero instance works. I can send a simple message and get a response.
+⚠️ Some tools like code execution will not work yet as they need to be connected to a Dockerized instance.
+
+![First message](res/dev/devinst-8.png)
+
+
+## Debugging
+- You can try out the debugger already by placing a breakpoint somewhere in the python code.
+- Let's open `python/api/message.py` for example and place a breakpoint at the beginning of the `communicate` function by clicking on the left of the row number. A red dot should appear showing a breakpoint is set.
+
+![Debugging](res/dev/devinst-9.png)
+
+- Now when I send a message in the UI, the debugger will pause the execution at the breakpoint and allow me to inspect all the runtime variables and run the code step by step, even modify the variables or jump to another locations in the code. No more print statements needed!
+
+![Debugging](res/dev/devinst-10.png)
+
+
+## Step 5: Run another instance of Agent Zero in Docker
+- Some parts of A0 require standardized linux environment, additional web services and preinstalled binaries that would be unneccessarily complex to set up in a local environment.
+- To make development easier, we can use existing A0 instance in docker and forward some requests to be executed there using SSH and RFC (Remote Function Call).
+
+1. Pull the docker image `agent0ai/agent-zero` from Docker Hub and run it with a web port (`80`) mapped and SSH port (`22`) mapped.
+If you want, you can also map the `/a0` folder to our local project folder as well, this way we can update our local instance and the docker instance at the same time.
+This is how it looks in my example: port `80` is mapped to `8880` on the host and `22` to `8822`, `/a0` folder mapped to `/Users/frdel/Desktop/agent-zero`:
+
+![docker run](res/dev/devinst-11.png)
+![docker run](res/dev/devinst-12.png)
+
+
+## Step 6: Configure SSH and RFC connection
+- The last step is to configure the local development (VS Code) instance and the dockerized instance to communicate with each other. This is very simple and can be done in the settings in the Web UI of both instances.
+- In my example the dark themed instance is the VS Code one, the light themed one is the dockerized instance.
+
+1. Open the "Settings" page in the Web UI of your dockerized instance and go in the "Development" section.
+2. Set the `RFC Password` field to a new password and save.
+3. Open the "Settings" page in the Web UI of your local instance and go in the "Development" section.
+4. Here set the `RFC Password` field to the same password you used in the dockerized instance. Also set the SSH port and HTTP port the same numbers you used when creating the container - in my case `8822` for SSH and `8880` for HTTP. The `RFC Destination URL` will most probably stay `localhost` as both instances are running on the host machine.
+5. Click save and test by asking your agent to do something in the terminal, like "Get current OS version". It should be able to communicate with the dockerized instance via RFC and SSH and execute the command there, responding with something like "Kali GNU/Linux Rolling".
+
+My Dockerized instance:
+![Dockerized instance](res/dev/devinst-14.png)
+
+My VS Code instance:
+![VS Code instance](res/dev/devinst-13.png)
+
+
+# 🎉 Congratulations! 🚀
+
+You have successfully set up a complete Agent Zero development environment! You now have:
+
+- ✅ A local development instance running in your IDE with full debugging capabilities
+- ✅ A dockerized instance for code execution and system operations
+- ✅ RFC and SSH communication between both instances
+- ✅ The ability to develop, debug, and test Agent Zero features seamlessly
+
+You're now ready to contribute to Agent Zero, create custom extensions, or modify the framework to suit your needs. Happy coding! 💻✨
+
+
+## Next steps
+- See [extensibility](extensibility.md) for instructions on how to create custom extensions.
+- See [contribution](contribution.md) for instructions on how to contribute to the framework.

docs/extensibility.md

@@ -0,0 +1,240 @@
+# Extensibility framework in Agent Zero
+
+> [!NOTE] Agent Zero is built with extensibility in mind. It provides a framework for creating custom extensions, agents, instruments, and tools that can be used to enhance the functionality of the framework.
+
+## Extensible components
+- The Python framework controlling Agent Zero is built as simple as possible, relying on independent smaller and modular scripts for individual tools, API endpoints, system extensions and helper scripts.
+- This way individual components can be easily replaced, upgraded or extended.
+
+Here's a summary of the extensible components:
+
+### Extensions
+Extensions are components that hook into specific points in the agent's lifecycle. They allow you to modify or enhance the behavior of Agent Zero at predefined extension points. The framework uses a plugin-like architecture where extensions are automatically discovered and loaded.
+
+#### Extension Points
+Agent Zero provides several extension points where custom code can be injected:
+
+- **agent_init**: Executed when an agent is initialized
+- **before_main_llm_call**: Executed before the main LLM call is made
+- **message_loop_start**: Executed at the start of the message processing loop
+- **message_loop_prompts_before**: Executed before prompts are processed in the message loop
+- **message_loop_prompts_after**: Executed after prompts are processed in the message loop
+- **message_loop_end**: Executed at the end of the message processing loop
+- **monologue_start**: Executed at the start of agent monologue
+- **monologue_end**: Executed at the end of agent monologue
+- **reasoning_stream**: Executed when reasoning stream data is received
+- **response_stream**: Executed when response stream data is received
+- **system_prompt**: Executed when system prompts are processed
+
+#### Extension Mechanism
+The extension mechanism in Agent Zero works through the `call_extensions` function in `agent.py`, which:
+
+1. Loads default extensions from `/python/extensions/{extension_point}/`
+2. Loads agent-specific extensions from `/agents/{agent_profile}/extensions/{extension_point}/`
+3. Merges them, with agent-specific extensions overriding default ones based on filename
+4. Executes each extension in order
+
+#### Creating Extensions
+To create a custom extension:
+
+1. Create a Python class that inherits from the `Extension` base class
+2. Implement the `execute` method
+3. Place the file in the appropriate extension point directory:
+   - Default extensions: `/python/extensions/{extension_point}/`
+   - Agent-specific extensions: `/agents/{agent_profile}/extensions/{extension_point}/`
+
+**Example extension:**
+
+```python
+# File: /agents/_example/extensions/agent_init/_10_example_extension.py
+from python.helpers.extension import Extension
+
+class ExampleExtension(Extension):
+    async def execute(self, **kwargs):
+        # rename the agent to SuperAgent0
+        self.agent.agent_name = "SuperAgent" + str(self.agent.number)
+```
+
+#### Extension Override Logic
+When an extension with the same filename exists in both the default location and an agent-specific location, the agent-specific version takes precedence. This allows for selective overriding of extensions while inheriting the rest of the default behavior.
+
+For example, if both these files exist:
+- `/python/extensions/agent_init/example.py`
+- `/agents/my_agent/extensions/agent_init/example.py`
+
+The version in `/agents/my_agent/extensions/agent_init/example.py` will be used, completely replacing the default version.
+
+### Tools
+Tools are modular components that provide specific functionality to agents. They are invoked by the agent through tool calls in the LLM response. Tools are discovered dynamically and can be extended or overridden.
+
+#### Tool Structure
+Each tool is implemented as a Python class that inherits from the base `Tool` class. Tools are located in:
+- Default tools: `/python/tools/`
+- Agent-specific tools: `/agents/{agent_profile}/tools/`
+
+#### Tool Override Logic
+When a tool with the same name is requested, Agent Zero first checks for its existence in the agent-specific tools directory. If found, that version is used. If not found, it falls back to the default tools directory.
+
+**Example tool override:**
+
+```python
+# File: /agents/_example/tools/response.py
+from python.helpers.tool import Tool, Response
+
+# example of a tool redefinition
+# the original response tool is in python/tools/response.py
+# for the example agent this version will be used instead
+
+class ResponseTool(Tool):
+    async def execute(self, **kwargs):
+        print("Redefined response tool executed")
+        return Response(message=self.args["text"] if "text" in self.args else self.args["message"], break_loop=True)
+```
+
+#### Tool Execution Flow
+When a tool is called, it goes through the following lifecycle:
+1. Tool initialization
+2. `before_execution` method
+3. `execute` method (main functionality)
+4. `after_execution` method
+
+### API Endpoints
+API endpoints expose Agent Zero functionality to external systems or the user interface. They are modular and can be extended or replaced.
+
+API endpoints are located in:
+- Default endpoints: `/python/api/`
+
+Each endpoint is a separate Python file that handles a specific API request.
+
+### Helpers
+Helper modules provide utility functions and shared logic used across the framework. They support the extensibility of other components by providing common functionality.
+
+Helpers are located in:
+- Default helpers: `/python/helpers/`
+
+### Prompts
+Prompts define the instructions and context provided to the LLM. They are highly extensible and can be customized for different agents.
+
+Prompts are located in:
+- Default prompts: `/prompts/`
+- Agent-specific prompts: `/agents/{agent_profile}/prompts/`
+
+#### Prompt Features
+Agent Zero's prompt system supports several powerful features:
+
+##### Variable Placeholders
+Prompts can include variables using the `{{var}}` syntax. These variables are replaced with actual values when the prompt is processed.
+
+**Example:**
+```markdown
+# Current system date and time of user
+- current datetime: {{date_time}}
+- rely on this info always up to date
+```
+
+##### Dynamic Variable Loaders
+For more advanced prompt customization, you can create Python files with the same name as your prompt files. These Python files act as dynamic variable loaders that generate variables at runtime.
+
+When a prompt file is processed, Agent Zero automatically looks for a corresponding `.py` file in the same directory. If found, it uses this Python file to generate dynamic variables for the prompt.
+
+**Example:**
+If you have a prompt file `agent.system.tools.md`, you can create `agent.system.tools.py` alongside it:
+
+```python
+from python.helpers.files import VariablesPlugin
+from python.helpers import files
+
+class Tools(VariablesPlugin):
+    def get_variables(self, file: str, backup_dirs: list[str] | None = None) -> dict[str, Any]:
+        # Dynamically collect all tool instruction files
+        folder = files.get_abs_path(os.path.dirname(file))
+        folders = [folder]
+        if backup_dirs:
+            folders.extend([files.get_abs_path(d) for d in backup_dirs])
+        
+        prompt_files = files.get_unique_filenames_in_dirs(folders, "agent.system.tool.*.md")
+        
+        tools = []
+        for prompt_file in prompt_files:
+            tool = files.read_file(prompt_file)
+            tools.append(tool)
+        
+        return {"tools": "\n\n".join(tools)}
+```
+
+Then in your `agent.system.tools.md` prompt file, you can use:
+```markdown
+# Available Tools
+{{tools}}
+```
+
+This approach allows for highly dynamic prompts that can adapt based on available extensions, configurations, or runtime conditions. See existing examples in the `/prompts/` directory for reference implementations.
+
+##### File Includes
+Prompts can include content from other prompt files using the `{{ include "./path/to/file.md" }}` syntax. This allows for modular prompt design and reuse.
+
+**Example:**
+```markdown
+# Agent Zero System Manual
+
+{{ include "./agent.system.main.role.md" }}
+
+{{ include "./agent.system.main.environment.md" }}
+
+{{ include "./agent.system.main.communication.md" }}
+```
+
+#### Prompt Override Logic
+Similar to extensions and tools, prompts follow an override pattern. When the agent reads a prompt, it first checks for its existence in the agent-specific prompts directory. If found, that version is used. If not found, it falls back to the default prompts directory.
+
+**Example of a prompt override:**
+
+```markdown
+> !!!
+> This is an example prompt file redefinition.
+> The original file is located at /prompts.
+> Only copy and modify files you need to change, others will stay default.
+> !!!
+
+## Your role
+You are Agent Zero, a sci-fi character from the movie "Agent Zero".
+```
+
+This example overrides the default role definition in `/prompts/agent.system.main.role.md` with a custom one for a specific agent profile.
+
+## Subagent Customization
+Agent Zero supports creating specialized subagents with customized behavior. The `_example` agent in the `/agents/_example/` directory demonstrates this pattern.
+
+### Creating a Subagent
+
+1. Create a directory in `/agents/{agent_profile}/`
+2. Override or extend default components by mirroring the structure in the root directories:
+   - `/agents/{agent_profile}/extensions/` - for custom extensions
+   - `/agents/{agent_profile}/tools/` - for custom tools
+   - `/agents/{agent_profile}/prompts/` - for custom prompts
+
+### Example Subagent Structure
+
+```
+/agents/_example/
+├── extensions/
+│   └── agent_init/
+│       └── _10_example_extension.py
+├── prompts/
+│   └── ...
+└── tools/
+    ├── example_tool.py
+    └── response.py
+```
+
+In this example:
+- `_10_example_extension.py` is an extension that renames the agent when initialized
+- `response.py` overrides the default response tool with custom behavior
+- `example_tool.py` is a new tool specific to this agent
+
+## Best Practices
+- Keep extensions focused on a single responsibility
+- Use the appropriate extension point for your functionality
+- Leverage existing helpers rather than duplicating functionality
+- Test extensions thoroughly to ensure they don't interfere with core functionality
+- Document your extensions to make them easier to maintain and share

docs/installation.md

@@ -50,8 +50,8 @@ The following user guide provides instructions for installing and running Agent
 <img src="res/setup/image-13.png" alt="docker installed" height="100"/>
 <br><br>
 
-> [!IMPORTANT]  
-> **macOS Configuration:** In Docker Desktop's preferences (Docker menu) → Settings → 
+> [!NOTE]
+> **MacOS Configuration:** In Docker Desktop's preferences (Docker menu) → Settings → 
 > Advanced, enable "Allow the default Docker socket to be used (requires password)."
 
 ![docker socket macOS](res/setup/macsocket.png)
@@ -74,17 +74,24 @@ The following user guide provides instructions for installing and running Agent
 > docker pull agent0ai/agent-zero
 > ```
 
-2.2. Create a data directory for persistence:
+2.2. OPTIONAL - Create a data directory for persistence:
+
+> [!CAUTION]
+> Preferred way of persisting Agent Zero data is to use the backup and restore feature.
+> By mapping the whole `/a0` directory to a local directory, you will run into problems when upgrading Agent Zero to a newer version.
+
 - Choose or create a directory on your machine where you want to store Agent Zero's data
 - This can be any location you prefer (e.g., `C:/agent-zero-data` or `/home/user/agent-zero-data`)
+- You can map individual subfolders of `/a0` to a local directory or the full `/a0` directory (not recommended).
 - This directory will contain all your Agent Zero files, like the legacy root folder structure:
+  - `/agents` - Specialized agents with their prompts and tools
   - `/memory` - Agent's memory and learned information
   - `/knowledge` - Knowledge base
   - `/instruments` - Instruments and functions
   - `/prompts` - Prompt files
   - `/work_dir` - Working directory
   - `.env` - Your API keys
-  - `settings.json` - Your Agent Zero settings
+  - `/tmp/settings.json` - Your Agent Zero settings
 
 > [!TIP]
 > Choose a location that's easy to access and backup. All your Agent Zero data 
@@ -94,16 +101,22 @@ The following user guide provides instructions for installing and running Agent
 - In Docker Desktop, go back to the "Images" tab
 - Click the `Run` button next to the `agent0ai/agent-zero` image
 - Open the "Optional settings" menu
-- Set the port to `0` in the second "Host port" field (for automatic port assignment)
+- Set the web port (80) to desired host port number in the second "Host port" field or set to `0` for automatic port assignment
 
 Optionally you can map local folders for file persistence:
-- Under "Volumes", configure:
-  - Host path: Your chosen directory (e.g., `C:\agent-zero-data`)
-  - Container path: `/a0`
+> [!CAUTION]
+> Preferred way of persisting Agent Zero data is to use the backup and restore feature.
+> By mapping the whole `/a0` directory to a local directory, you will run into problems when upgrading Agent Zero to a newer version.
+- OPTIONAL: Under "Volumes", configure your mapped folders, if needed:
+  - Example host path: Your chosen directory (e.g., `C:\agent-zero\memory`)
+  - Example container path: `/a0/memory`
 
-![docker port mapping](res/setup/3-docker-port-mapping.png)
 
 - Click the `Run` button in the "Images" tab.
+
+![docker port mapping](res/setup/2-docker-image-run.png)
+![docker port mapping](res/setup/2-docker-image-run2.png)
+
 - The container will start and show in the "Containers" tab
 
 ![docker containers](res/setup/4-docker-container-started.png)
@@ -205,11 +218,6 @@ The Settings page is the control center for selecting the Large Language Models
 
 ## Important Considerations
 
-> [!CAUTION]
-> Changing the `embedding_llm` will re-index all the memory and knowledge, and 
-> requires clearing the `memory` folder to avoid errors, as the embeddings can't be 
-> mixed in the vector database. Note that this will DELETE ALL of Agent Zero's memory.
-
 ## Installing and Using Ollama (Local Models)
 If you're interested in Ollama, which is a powerful tool that allows you to run various large language models locally, here's how to install and use it:
 
@@ -251,7 +259,9 @@ ollama pull <model-name>
 
 3. Write your model code as expected by Ollama, in the format `llama3.2` or `qwen2.5:7b`
 
-4. Click `Save` to confirm your settings.
+4. Provide your API base URL to your ollama API endpoint, usually `http://host.docker.internal:11434`
+
+5. Click `Save` to confirm your settings.
 
 ![ollama](res/setup/settings/4-local-models.png)
 
@@ -275,6 +285,10 @@ Once you've downloaded some models, you might want to check which ones you have
 ## Using Agent Zero on your mobile device
 Agent Zero's Web UI is accessible from any device on your network through the Docker container:
 
+> [!NOTE]
+> In settings, External Services tab, you can enable Cloudflare Tunnel to expose your Agent Zero instance to the internet.
+> ⚠️ Do not forget to set username and password in the settings Authentication tab to secure your instance on the internet.
+
 1. The Docker container automatically exposes the Web UI on all network interfaces
 2. Find the mapped port in Docker Desktop:
    - Look under the container name (usually in the format `<PORT>:80`)
@@ -296,6 +310,10 @@ For developers or users who need to run Agent Zero directly on their system,see
 
 # How to update Agent Zero
 
+> [!NOTE]
+> Since v0.9, Agent Zero has a Backup and Restore feature, so you don't need to backup the files manually.
+> In Settings, Backup and Restore tab will guide you through the process.
+
 1. **If you come from the previous version of Agent Zero:**
 - Your data is safely stored across various directories and files inside the Agent Zero folder.
 - To update to the new Docker runtime version, you might want to backup the following files and directories:
@@ -347,208 +365,9 @@ For developers or users who need to run Agent Zero directly on their system,see
 > docker run -p $PORT:80 -v /path/to/your/data:/a0 agent0ai/agent-zero
 > ```
 
-3. **Full Binaries**
-- Using Git/GitHub: Pull the latest version of the Agent Zero repository. 
-- The custom knowledge, solutions, memory, and other data will get ignored, so you don't need to worry about losing any of your custom data. The same goes for your .env file with all of your API keys and settings.json.
-
-> [!WARNING]  
-> - If you update manually, beware: save your .env file with the API keys, and look for new dependencies in requirements.txt. 
-> - If any changes are made to the requirements of the updated version, you have to execute this command inside the a0 conda env after activating it:
-> ```bash
-> pip install -r requirements.txt
-
-# In-Depth Guide for Full Binaries Installation
-- Agent Zero is a framework. It's made to be customized, edited, enhanced. Therefore you need to install the necessary components to run it when downloading its full binaries. This guide will help you to do so.
-- The following step by step instructions can be followed along with a video for this tutorial on how to make Agent Zero work with its full development environment.
-
-[![Video](res/setup/thumb_play.png)](https://youtu.be/8H7mFsvxKYQ)
-
-## Reminders:
-1. There's no need to install Python, Conda will manage that for you.
-2. You don't necessarily need API keys: Agent Zero can run with local models. For this tutorial though, we will leave it to the default OpenAI API. A guide for downloading Ollama along with local models is available [here](#installing-and-using-ollama-local-models).
-3. Visual Studio Code or any other code editor is not mandatory, but it makes it easier to navigate and edit files.
-4. Git/GitHub is not mandatory, you can download the framework files through your browser. We will not be showing how to use Git in this tutorial.
-5. Docker is not mandatory for the full binaries installation, since the framework will run on your machine connecting to the Docker container through the Web UI RFC functionality.
-6. Running Agent Zero without Docker makes the process more complicated and it's thought for developers and contributors.
-
-> [!IMPORTANT]  
-> Linux instructions are provided as general instructions for any Linux distribution. If you're using a distribution other than Debian/Ubuntu, you may need to adjust the instructions accordingly.
->
-> For Debian/Ubuntu, just follow the macOS instructions, as they are the same.
-
-## 1. Install Conda (miniconda)
-- Conda is a Python environment manager, it will help you keep your projects and installations separated. 
-- It's a lightweight version of Anaconda that includes only conda, Python, the packages they depend on, and a small number of other useful packages, including pip, zlib and a few others.
-
-1. Go to the download page of miniconda [here](https://docs.anaconda.com/miniconda/#miniconda-latest-installer-links). If the link does not work, just search the web for "miniconda download".
-2. Based on your operating system, download the right installer of miniconda. For macOS select the version with "pkg" at the end.
-
-<img src="res/setup/image-1.png" alt="miniconda download win" width="500"/>
-<img src="res/setup/image-5.png" alt="miniconda download macos" width="500"/>
-<br><br>
-
-3. Run the installer and go through the installation process, here you can leave everything to default and just click Next, Next... The same goes for macOS with the "pkg" graphical installer.
-
-<img src="res/setup/image.png" alt="miniconda install" width="200"/>
-<img src="res/setup/image-2.png" alt="miniconda install" width="200"/>
-<img src="res/setup/image-3.png" alt="miniconda install" width="200"/>
-<img src="res/setup/image-4.png" alt="miniconda install" width="200"/>
-<br><br>
-
-4. After the installation is complete, you should have "Anaconda Powershell Prompt" installed on your Windows machine. On macOS, when you open the Terminal application in your Applications folder and type "conda --version", you should see the version installed.
-
-<img src="res/setup/image-6.png" alt="miniconda installed" height="100"/>
-<img src="res/setup/image-7.png" alt="miniconda installed" height="100"/>
-<br><br>
-
-
-## 2. Download Agent Zero
-- You can clone the Agent Zero repository (https://github.com/agent0ai/agent-zero) from GitHub if you know how to use Git. In this tutorial I will just show how to download the files.
-
-1. Go to the Agent Zero releases [here](https://github.com/agent0ai/agent-zero/releases).
-2. The latest release is on the top of the list, click the "Source Code (zip)" button under "Assets" to download it.
-
-<img src="res/setup/image-14-u.png" alt="agent zero download" width="500"/>
-<br><br>
-
-3. Extract the downloaded archive where you want to have it. I will extract them to "agent-zero" folder on my Desktop - "C:\Users\frdel\Desktop\agent-zero" on Windows and "/Users/frdel/Desktop/agent-zero" on macOS.
-
-## 3. Set up Conda environment
-- Now that we have the project files and Conda, we can create **virtual Python environment** for this project, activate it and install requirements.
-
-1. Open your **"Anaconda Powershell Prompt"** application on windows or **"Terminal"** application on macOS.
-2. In the terminal, navigate to your Agent Zero folder using **"cd"** command. Replace the path with your actual Agent Zero folder path.
-~~~
-cd C:\Users\frdel\Desktop\agent-zero
-~~~
-You should see your folder has changed on the next terminal line.
-
-<img src="res/setup/image-15.png" alt="agent zero cd" height="100"/>
-<img src="res/setup/image-16.png" alt="agent zero cd" height="100"/>
-<br><br>
-
-3. Create Conda environment using command **"conda create"**. After **"-n"** is your environment name, you can choose your own, i will use **"a0"** - short for Agent Zero. After **"python"** is the Python version that Conda will install for you into this environment, right now, 3.12 works fine. **-y** skips confirmations.
-~~~
-conda create -n a0 python=3.12 -y
-~~~
-
-4. Once done, activate the new environment for this terminal window by another command:
-~~~
-conda activate a0
-~~~
-And you should see that the **(base)** on the left has changed to **(a0)**. This means that this terminal now uses the new **a0** virtual environment and all packages will be installed into this environment.
-
-<img src="res/setup/image-17.png" alt="conda env" height="200"/>
-<img src="res/setup/image-18.png" alt="conda env" height="200"/>
-<br><br>
-
-> [!IMPORTANT]  
-> If you open a new terminal window, you will need to activate the environment with 
-> "conda activate a0" again for that window.
-
-5. Install requirements using **"pip"**. Pip is a Python package manager. We can install all required packages from requirements.txt file using command:
-~~~
-pip install -r requirements.txt
-~~~
-This might take some time. If you get any errors regarding version conflicts and compatibility, double check that your environment is activated and that you created that environment with the correct Python version.
-
-<img src="res/setup/image-19.png" alt="conda reqs" height="200"/>
-<br><br>
-
-## 4. Install Docker (Docker Desktop application)
-Simply put, Docker is a way of running virtual computers on your machine. These are lightweight, disposable and isolated from your operating system, so it is a way to sandbox Agent Zero.
-- Agent Zero only connects to the Docker container when it needs to execute code and commands. The frameworks itself runs on your machine.
-- Docker has a desktop application with GUI for all major operating system, which is the recommended way to install it.
-
-1. Go to the download page of Docker Desktop [here](https://www.docker.com/products/docker-desktop/). If the link does not work, just search the web for "docker desktop download".
-2. Download the version for your operating system. Don't be tricked by the seemingly missing windows intel/amd version, it's the button itself, not in the dropdown menu.
-
-<img src="res/setup/image-8.png" alt="docker download" width="200"/>
-<br><br>
-
-3. Run the installer and go through the installation process. It should be even shorter than Conda installation, you can leave everything to default. On macOS, the installer is a "dmg" image, so just drag and drop the application to your Applications folder like always.
-
-<img src="res/setup/image-9.png" alt="docker install" width="300"/>
-<img src="res/setup/image-10.png" alt="docker install" width="300"/>
-
-<img src="res/setup/image-12.png" alt="docker install" width="300"/>
-<br><br>
-
-
-4. Once installed, you should see Docker Desktop application on your Windows/Mac machine. 
-
-<img src="res/setup/image-11.png" alt="docker installed" height="100"/>
-<img src="res/setup/image-13.png" alt="docker installed" height="100"/>
-<br><br>
-
-5. Create account in the application.
-- It's required to be signed in to the Docker Hub, so create a free account in the Docker Desktop application, you will be prompted when the application first runs.
-
-> [!IMPORTANT]  
-> **Important macOS-only Docker Configuration:** In Docker Desktop's preferences 
-> (Docker menu) go to Settings, navigate to "Advanced" and check "Allow the default 
-> Docker socket to be used (requires password)."  This allows Agent Zero to 
-> communicate with the Docker daemon.
-
-![docker socket macOS](res/setup/macsocket.png)
-
-> [!NOTE]
-> **Linux Users:** You can install both Docker Desktop or docker-ce (Community Edition). 
-> For Docker Desktop, follow the instructions for your specific Linux distribution [here](https://docs.docker.com/desktop/install/linux-install/). 
-> For docker-ce, follow the instructions [here](https://docs.docker.com/engine/install/).
->
-> If you're using docker-ce, you will need to add your user to the `docker` group to be able to run docker commands without sudo. You can do this by running the following command in your terminal: `sudo usermod -aG docker $USER`. Then log out and log back in for the changes to take effect.
->
-> Login in the Docker CLI with `docker login` and provide your Docker Hub credentials.
-
-6. Pull the Docker image
-- Agent Zero needs a Docker image to be pulled from the Docker Hub to be run, even when using the full binaries.
-You can refer to the [installation instructions above](#windows-macos-and-linux-setup-guide) to run the Docker container and then resume from the next step. There are two differences:
-  - You need to map two ports instead of one:
-    - 55022 in the first field to run the Remote Function Call SSH
-    - 0 in the second field to run the Web UI in automatic port assignment
-  - You need to map the `/a0` volume to the location of your local Agent Zero folder.
-- Run the Docker container following the instructions.
-
-## 5. Run the local Agent Zero instance
-Run the Agent Zero with Web UI:
-~~~
-python run_ui.py
-~~~
-
-<img src="res/setup/image-21.png" alt="run ui" height="110"/>
-<br><br>
-
-- Open the URL shown in terminal in your web browser. You should see the Agent Zero interface.
-
-## 6. Configure Agent Zero
-Now we can configure Agent Zero - select models, settings, API Keys etc. Refer to the [Usage](usage.md#agent-configuration) guide for a full guide on how to configure Agent Zero.
-
-## 7. Configure Agent Zero RFC
-Agent Zero needs to be configured further to redirect some functions to the Docker container. This is crucial for development as A0 needs to run in a standardized environment to support all features.
-1. Go in "Settings" page in the Web UI of your local instance and go in the "Development" section.
-2. Set "RFC Destination URL" to `http://localhost`
-3. Set the two ports (HTTP and SSH) to the ones used when creating the Docker container
-4. Click "Save"
-
-![rfc local settings](res/setup/9-rfc-devpage-on-local-sbs-1.png)
-
-5. Go in "Settings" page in the Web UI of your Docker instance and go in the "Development" section.
-
-![rfc docker settings](res/setup/9-rfc-devpage-on-docker-instance-1.png)
-
-6. This time the page has only the password field, set it to the same password you used when creating the Docker container.
-7. Click "Save"
-8. Use the Development environment
-9. Now you have the full development environment to work on Agent Zero.
-
-<img src="res/setup/image-22-1.png" alt="run ui" width="400"/>
-<img src="res/setup/image-23-1.png" alt="run ui" width="400"/>
-<br><br>
-
       
 ### Conclusion
 After following the instructions for your specific operating system, you should have Agent Zero successfully installed and running. You can now start exploring the framework's capabilities and experimenting with creating your own intelligent agents. 
 
-If you encounter any issues during the installation process, please consult the [Troubleshooting section](troubleshooting.md) of this documentation or refer to the Agent Zero [Skool](https://www.skool.com/agent-zero) or [Discord](https://discord.gg/Z2tun2N3) community for assistance.
+If you encounter any issues during the installation process, please consult the [Troubleshooting section](troubleshooting.md) of this documentation or refer to the Agent Zero [Skool](https://www.skool.com/agent-zero) or [Discord](https://discord.gg/B8KZKNsPpj) community for assistance.
 

docs/mcp_setup.md

@@ -44,7 +44,7 @@ Within `tmp/settings.json`, the MCP servers are defined under the `"mcp_servers"
 ```json
 {
     // ... other settings ...
-    "mcp_servers": "[{\\\"name\\\": \\\"sequential-thinking\\\",\\\"command\\\": \\\"npx\\\",\\\"args\\\": [\\\"--yes\\\", \\\"--package\\\", \\\"@modelcontextprotocol/server-sequential-thinking\\\", \\\"mcp-server-sequential-thinking\\\"]}, {\\\"name\\\": \\\"brave-search\\\", \\\"command\\\": \\\"npx\\\", \\\"args\\\": [\\\"--yes\\\", \\\"--package\\\", \\\"@modelcontextprotocol/server-brave-search\\\", \\\"mcp-server-brave-search\\\"], \\\"env\\\": {\\\"BRAVE_API_KEY\\\": \\\"YOUR_BRAVE_KEY_HERE\\\"}}, {\\\"name\\\": \\\"fetch\\\", \\\"command\\\": \\\"npx\\\", \\\"args\\\": [\\\"--yes\\\", \\\"--package\\\", \\\"@tokenizin/mcp-npx-fetch\\\", \\\"mcp-npx-fetch\\\", \\\"--ignore-robots-txt\\\", \\\"--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36\\\"]}]",
+    "mcp_servers": "[{'name': 'sequential-thinking','command': 'npx','args': ['--yes', '--package', '@modelcontextprotocol/server-sequential-thinking', 'mcp-server-sequential-thinking']}, {'name': 'brave-search', 'command': 'npx', 'args': ['--yes', '--package', '@modelcontextprotocol/server-brave-search', 'mcp-server-brave-search'], 'env': {'BRAVE_API_KEY': 'YOUR_BRAVE_KEY_HERE'}}, {'name': 'fetch', 'command': 'npx', 'args': ['--yes', '--package', '@tokenizin/mcp-npx-fetch', 'mcp-npx-fetch', '--ignore-robots-txt', '--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36']}]",
     // ... other settings ...
 }
 ```
@@ -120,7 +120,7 @@ Here are templates for configuring individual servers within the `mcp_servers` J
 ```json
 {
     // ... other settings ...
-    "mcp_servers": "[{\\\"name\\\": \\\"MyPythonTools\\\", \\\"command\\\": \\\"python3\\\", \\\"args\\\": [\\\"mcp_scripts/my_server.py\\\"], \\\"disabled\\\": false}, {\\\"name\\\": \\\"ExternalAPI\\\", \\\"url\\\": \\\"https://data.example.com/mcp\\\", \\\"headers\\\": {\\\"X-Auth-Token\\\": \\\"supersecret\\\"}, \\\"disabled\\\": false}]",
+    "mcp_servers": "[{'name': 'MyPythonTools', 'command': 'python3', 'args': ['mcp_scripts/my_server.py'], 'disabled': false}, {'name': 'ExternalAPI', 'url': 'https://data.example.com/mcp', 'headers': {'X-Auth-Token': 'supersecret'}, 'disabled': false}]",
     // ... other settings ...
 }
 ```

docs/troubleshooting.md

@@ -18,7 +18,7 @@ Refer to the [Choosing your LLMs](installation.md#installing-and-using-ollama-lo
 Refer to the [How to update Agent Zero](installation.md#how-to-update-agent-zero) section of the documentation for instructions on how to update Agent Zero while retaining memory and data.
 
 **7. Where can I find more documentation or tutorials?**
--   Join the Agent Zero [Skool](https://www.skool.com/agent-zero) or [Discord](https://discord.gg/Z2tun2N3) community for support and discussions.
+-   Join the Agent Zero [Skool](https://www.skool.com/agent-zero) or [Discord](https://discord.gg/B8KZKNsPpj) community for support and discussions.
 
 **8. How do I adjust API rate limits?**
 Modify the `rate_limit_seconds` and `rate_limit_requests` parameters in the `AgentConfig` class within `initialize.py`.

docs/usage.md

@@ -100,16 +100,16 @@ Agent Zero supports direct file attachments in the chat interface for seamless f
 ## Tool Usage
 Agent Zero's power comes from its ability to use [tools](architecture.md#tools). Here's how to leverage them effectively:
 
-- **Understand Tools:** Agent Zero includes default tools like knowledge (powered by SearXNG), webpage content, code execution, and communication. Understand the capabilities of these tools and how to invoke them.
+- **Understand Tools:** Agent Zero includes default tools like knowledge (powered by SearXNG), code execution, and communication. Understand the capabilities of these tools and how to invoke them.
 
 ## Example of Tools Usage: Web Search and Code Execution
 Let's say you want Agent Zero to perform some financial analysis tasks. Here's a possible prompt:
 
-> Please be a professional financial analyst. Find last month Bitcoin/ USD price trend and make a chart in your environment. The chart must  have highlighted key points corresponding with dates of major news  about cryptocurrency. Use the 'knowledge_tool' to find the price and  the news, and the 'code_execution_tool' to perform the rest of the job.
+> Please be a professional financial analyst. Find last month Bitcoin/ USD price trend and make a chart in your environment. The chart must  have highlighted key points corresponding with dates of major news  about cryptocurrency. Use the 'search_engine' and 'document_query_tool' to find the price and  the news, and the 'code_execution_tool' to perform the rest of the job.
 
 Agent Zero might then:
 
-1. Use the `knowledge_tool` to query a reliable source for the Bitcoin price and for the news about cryptocurrency as prompted.
+1. Use the `search_engine` and `document_query_tool` to query a reliable source for the Bitcoin price and for the news about cryptocurrency as prompted.
 2. Extract the price from the search results and save the news, extracting their dates and possible impact on the price.
 3. Use the `code_execution_tool` to execute a Python script that performs the graph creation and key points highlighting, using the extracted data and the news dates as inputs.
 4. Return the final chart that you'll find in `/work_dir`, responding to the user with the `response_tool`.

knowledge/default/main/about/github_readme.md

@@ -11,7 +11,7 @@ To begin with Agent Zero, follow the links below for detailed guides on various
 ### Your experience with Agent Zero starts now!
 
 - **Download Agent Zero:** Follow the [installation guide](installation.md) to download and run Agent Zero.
-- **Join the Community:** Join the Agent Zero [Skool](https://www.skool.com/agent-zero) or [Discord](https://discord.gg/Z2tun2N3) community to discuss ideas, ask questions, and collaborate with other contributors.
+- **Join the Community:** Join the Agent Zero [Skool](https://www.skool.com/agent-zero) or [Discord](https://discord.gg/B8KZKNsPpj) community to discuss ideas, ask questions, and collaborate with other contributors.
 - **Share your Work:** Share your Agent Zero creations, workflows and discoverings on our [Show and Tell](https://github.com/agent0ai/agent-zero/discussions/categories/show-and-tell) area on GitHub.
 - **Report Issues:** Use the [GitHub issue tracker](https://github.com/agent0ai/agent-zero/issues) to report framework-relative bugs or suggest new features.
 

knowledge/default/main/about/installation.md

@@ -550,5 +550,5 @@ Agent Zero needs to be configured further to redirect some functions to the Dock
 ### Conclusion
 After following the instructions for your specific operating system, you should have Agent Zero successfully installed and running. You can now start exploring the framework's capabilities and experimenting with creating your own intelligent agents. 
 
-If you encounter any issues during the installation process, please consult the [Troubleshooting section](troubleshooting.md) of this documentation or refer to the Agent Zero [Skool](https://www.skool.com/agent-zero) or [Discord](https://discord.gg/Z2tun2N3) community for assistance.
+If you encounter any issues during the installation process, please consult the [Troubleshooting section](troubleshooting.md) of this documentation or refer to the Agent Zero [Skool](https://www.skool.com/agent-zero) or [Discord](https://discord.gg/B8KZKNsPpj) community for assistance.
 

prompts/agent.system.main.tips.md

@@ -4,7 +4,7 @@
 reason step-by-step execute tasks
 avoid repetition ensure progress
 never assume success
-memory refers to knowledge_tool and memory tools not own knowledge
+memory refers memory tools not own knowledge
 
 ## Files
 save files in /root

prompts/agent.system.tool.browser._md

@@ -1,83 +0,0 @@
-### browser_open:
-
-control stateful chromium browser using playwright
-use with url argument to open a new page
-all browser tools return simplified DOM with unique selectors
-once page is opened use browser_do tool to interact.
-
-```json
-{
-  "thoughts": ["I need to send..."],
-  "tool_name": "browser_open",
-  "tool_args": {
-    "url": "https://www.example.com"
-  }
-}
-```
-
-### browser_do:
-
-use to fill forms press keys click buttons execute javascript
-arguments are optional
-fill argument is array of objects with selector and text
-press argument is array of keys to be pressed in order - Enter, Escape...
-click argument is an array of selectors clicked in order
-execute argument is a string of javascript executed
-always prefer clicking on <a> or <button> tags first
-confirm fields with Enter or find submit button
-consents and popups may block page, close them
-only use selectors mentioned in last browser response
-do not repeat same steps if do not work! find ways around problems
-```json
-{
-  "thoughts": [
-    "Login required...",
-    "I will fill username, password, click remember me and submit."
-  ],
-  "tool_name": "browser_do",
-  "tool_args": {
-    "fill": [
-      {
-        "selector": "12l",
-        "text": "root"
-      },
-      {
-        "selector": "14vs",
-        "text": "toor"
-      }
-    ],
-    "click": ["19c", "65d"]
-  }
-}
-```
-
-```json
-{
-  "thoughts": [
-    "Search for...",
-    "I will fill search box and press Enter."
-  ],
-  "tool_name": "browser_do",
-  "tool_args": {
-    "fill": [
-      {
-        "selector": "98d",
-        "text": "example"
-      }
-    ],
-    "press": ["Enter"]
-  }
-}
-```
-
-```json
-{
-  "thoughts": [
-    "Standard interaction not possible, I need to execute custom code..."
-  ],
-  "tool_name": "browser_do",
-  "tool_args": {
-    "execute": "const elem = document.querySelector('[data-uid=\"4z\"]'); elem.click();"
-  }
-}
-```

prompts/agent.system.tool.code_exe.md

@@ -7,7 +7,7 @@ select "session" number, 0 default, others for multitasking
 if code runs long, use "output" to wait, "reset" to kill process
 use "pip" "npm" "apt-get" in "terminal" to install packages
 to output, use print() or console.log()
-if tool outputs error, adjust code before retrying; knowledge_tool can help
+if tool outputs error, adjust code before retrying; 
 important: check code for placeholders or demo data; replace with real variables; don't reuse snippets
 don't use with other tools except thoughts; wait for response before using others
 check dependencies before running code

prompts/agent.system.tool.knowledge.md

@@ -1,22 +0,0 @@
-### knowledge_tool:
-provide your question as a search engine - ready query
-the first responder will be a search engine not an ai or human
-formulate your query as concisely and precisely as possible
-provide question arg get online and memory response
-powerful tool answers specific questions directly
-ask for result first not guidance
-memory gives guidance online gives current info
-verify memory with online
-**Example usage**:
-~~~json
-{
-    "thoughts": [
-        "...",
-    ],
-    "headline": "Searching knowledge base and online resources",
-    "tool_name": "knowledge_tool",
-    "tool_args": {
-        "question": "How to...",
-    }
-}
-~~~

prompts/agent.system.tool.web.md

@@ -1,19 +0,0 @@
-### webpage_content_tool:
-get webpage text content news wiki etc
-use url arg for main text
-gather online content
-provide full valid url with http:// or https://
-
-**Example usage**:
-```json
-{
-    "thoughts": [
-        "...",
-    ],
-    "headline": "Extracting webpage text content",
-    "tool_name": "webpage_content_tool",
-    "tool_args": {
-        "url": "https://...comexample",
-    }
-}
-```

prompts/msg.memory_cleanup.md

@@ -1,26 +0,0 @@
-# Cleanup raw memories from database
-- You will receive two data collections:
-    1. Conversation history of AI agent.
-    2. Raw memories from vector database based on similarity score.
-- Your job is to remove all memories from the database that are not relevant to the topic of the conversation history and only return memories that are relevant and helpful for future of the conversation.
-- Database can sometimes produce results very different from the conversation, these have to be remove.
-- Focus on the end of the conversation history, that is where the most current topic is.
-
-# Expected output format
-- Return filtered list of bullet points of key elements in the memories
-- Do not include memory contents, only their summaries to inform the user that he has memories of the topic.
-- If there are relevant memories, instruct user to use "knowledge_tool" to get more details.
-
-# Example output 1 (relevant memories):
-~~~md
-1. Guide how to create a web app including code.
-2. Javascript snippets from snake game development.
-3. SVG image generation for game sprites with examples.
-
-Check your knowledge_tool for more details.
-~~~
-
-# Example output 2 (no relevant memories):
-~~~text
-No relevant memories on the topic found.
-~~~

python/api/image_get.py

@@ -24,7 +24,11 @@ class ImageGet(ApiHandler):
             raise ValueError("No path provided")
 
         # check if path is within base directory
-        if not runtime.call_development_function(files.is_in_base_dir, path):
+        if runtime.is_development():
+            in_base = files.is_in_base_dir(files.fix_dev_path(path))
+        else:
+            in_base = files.is_in_base_dir(path)
+        if not in_base:
             raise ValueError("Path is outside of allowed directory")
 
         # get file extension and info
@@ -37,30 +41,31 @@ class ImageGet(ApiHandler):
         # # If metadata is requested, return file information
         # if metadata:
         #     return _get_file_metadata(path, filename, file_ext, image_extensions)
-
+       
         if file_ext in image_extensions:
-            # Handle image files
-            if not runtime.call_development_function(files.exists, path):
-                # If image doesn't exist, return default image icon
-                return _send_fallback_icon("image")
 
-            # send image file right away if dockerized, if development, read it from docker and send
-            if runtime.is_dockerized():
-                response = send_file(path)
+            # in development environment, try to serve the image from local file system if exists, otherwise from docker
+            if runtime.is_development():
+                if files.exists(path):
+                    response = send_file(path)
+                elif await runtime.call_development_function(files.exists, path):
+                    b64_content = await runtime.call_development_function(
+                        files.read_file_base64, path
+                    )
+                    file_content = base64.b64decode(b64_content)
+                    mime_type, _ = guess_type(filename)
+                    if not mime_type:
+                        mime_type = "application/octet-stream"
+                    response = send_file(
+                        io.BytesIO(file_content),
+                        mimetype=mime_type,
+                        as_attachment=False,
+                        download_name=filename,
+                    )
+                else:
+                    response = _send_fallback_icon("image")
             else:
-                b64_content = await runtime.call_development_function(
-                    files.read_file_base64, path
-                )
-                file_content = base64.b64decode(b64_content)
-                mime_type, _ = guess_type(filename)
-                if not mime_type:
-                    mime_type = "application/octet-stream"
-                response = send_file(
-                    io.BytesIO(file_content),
-                    mimetype=mime_type,
-                    as_attachment=False,
-                    download_name=filename,
-                )
+                response = send_file(path)
 
             # Add cache headers for better device sync performance
             response.headers["Cache-Control"] = "public, max-age=3600"

python/helpers/memory_consolidation.py

@@ -592,8 +592,9 @@ class MemoryConsolidator:
             **result.metadata     # LLM metadata second (wins conflicts)
         }
 
-        if result.reasoning:
-            final_metadata['consolidation_reasoning'] = result.reasoning
+        # do not include reasoning in memory
+        # if result.reasoning:
+        #     final_metadata['consolidation_reasoning'] = result.reasoning
 
         new_id = await db.insert_text(result.new_memory_content, final_metadata)
         return [new_id]
@@ -624,8 +625,9 @@ class MemoryConsolidator:
                 **result.metadata     # LLM metadata second (wins conflicts)
             }
 
-            if result.reasoning:
-                final_metadata['consolidation_reasoning'] = result.reasoning
+            # do not include reasoning in memory
+            # if result.reasoning:
+            #     final_metadata['consolidation_reasoning'] = result.reasoning
 
             new_id = await db.insert_text(result.new_memory_content, final_metadata)
             return [new_id]
@@ -676,8 +678,9 @@ class MemoryConsolidator:
                         **result.metadata
                     }
 
-                    if result.reasoning:
-                        final_metadata['consolidation_reasoning'] = result.reasoning
+                    # do not include reasoning in memory
+                    # if result.reasoning:
+                    #     final_metadata['consolidation_reasoning'] = result.reasoning
 
                     new_id = await db.insert_text(result.new_memory_content, final_metadata)
                     return [new_id]
@@ -700,8 +703,9 @@ class MemoryConsolidator:
                 **result.metadata     # LLM metadata second (wins conflicts)
             }
 
-            if result.reasoning:
-                final_metadata['consolidation_reasoning'] = result.reasoning
+            # do not include reasoning in memory
+            # if result.reasoning:
+            #     final_metadata['consolidation_reasoning'] = result.reasoning
 
             new_id = await db.insert_text(result.new_memory_content, final_metadata)
             return [new_id]
@@ -762,8 +766,9 @@ class MemoryConsolidator:
                 **result.metadata     # LLM metadata second (wins conflicts)
             }
 
-            if result.reasoning:
-                final_metadata['consolidation_reasoning'] = result.reasoning
+            # do not include reasoning in memory
+            # if result.reasoning:
+            #     final_metadata['consolidation_reasoning'] = result.reasoning
 
             new_memory_id = await db.insert_text(result.new_memory_content, final_metadata)
             updated_ids.append(new_memory_id)

python/helpers/runtime.py

@@ -2,7 +2,7 @@ import argparse
 import inspect
 import secrets
 from typing import TypeVar, Callable, Awaitable, Union, overload, cast
-from python.helpers import dotenv, rfc, settings
+from python.helpers import dotenv, rfc, settings, files
 import asyncio
 import threading
 import queue
@@ -82,10 +82,11 @@ async def call_development_function(func: Union[Callable[..., T], Callable[...,
     if is_development():
         url = _get_rfc_url()
         password = _get_rfc_password()
+        module = files.deabsolute_path(func.__code__.co_filename).replace("/", ".").removesuffix(".py") # __module__ is not reliable
         result = await rfc.call_rfc(
             url=url,
             password=password,
-            module=func.__module__,
+            module=module,
             function_name=func.__name__,
             args=list(args),
             kwargs=kwargs,