agent-zero Documentation

File: README.md Copy Chapter

Why Agent Zero

Quick Start

Recommended: A0 Launcher Copy Chapter

The desktop A0 Launcher is the fastest guided path on a personal machine. Download it, open it, and let it check Docker, create Instances, manage ports, and connect to local or remote Agent Zero installs.

Agent Zero runs wherever Docker runs, from a $6 VPS or Raspberry Pi to a local workstation or GPU server.

See the A0 Launcher v1.5 release for release notes and updater metadata. See the Launcher guide for the first-run walkthrough.

Other install paths

A0 Install Copy Chapter

Use A0 Install when you want the terminal path: SSH sessions, servers, recovery shells, or a scriptable setup. It creates Dockerized Agent Zero instances, mounts each instance's data into /a0/usr inside the container, and uses a reuse-before-setup policy: it tries your current Docker CLI configuration, DOCKER_HOST, Docker contexts, and known local Docker-compatible endpoints before setting up a runtime.

macOS / Linux Copy Section

curl -fsSL https://bash.agent-zero.ai | bash

Windows PowerShell Copy Section

irm https://ps.agent-zero.ai | iex

Headless / scripted Copy Section

For servers and automation, run the installer in Quick Start mode so it creates one instance and exits without opening menus:

curl -fsSL https://bash.agent-zero.ai | bash -s -- --quick-start --name agent-zero --port 5080

& ([scriptblock]::Create((irm https://ps.agent-zero.ai))) -QuickStart -Name agent-zero -Port 5080

Use --skip-runtime-setup / -SkipRuntimeSetup when Docker must already be working and the installer should not try to set up a runtime. See the A0 Install repository for all installer flags.

Docker already installed? Run this directly Copy Chapter

docker run -p 80:80 -v a0_usr:/a0/usr agent0ai/agent-zero

Open the Web UI, configure your LLM provider, and start with a concrete task. For the full setup and onboarding experience, see the Installation guide.

Troubleshooting Copy Chapter

• Docker is not running: start Docker Desktop or your Docker service, then reopen the Launcher or rerun the install command.
• Port 80 is already in use: use the Launcher to pick another port, or run Docker directly with -p 5080:80 and open http://localhost:5080.
• Installing on a server: use the A0 Install Quick Start command with --quick-start --name agent-zero --port 5080.
• Still blocked: see the Troubleshooting guide.

Try These First

• Annotate a design you like: "Open this template site in the Browser. I'll annotate the hero section - re-implement it in my project's React + Tailwind stack."
• Cowork on a spreadsheet: "Create an editable ODS budget model with assumptions and monthly projections."
• Drive a desktop app: "Use the Linux Desktop to open Blender and create a simple 3D logo for me."
• Review a web UI: "Open my local app in the Browser. I will annotate the page with comments; then implement the requested UI fixes."
• Create a specialist: "Create an Agent Profile for financial analysis with cautious reasoning, clear assumptions, and spreadsheet-first deliverables."
• Recover a workspace: "Show me recent Time Travel snapshots and explain what changed before I revert anything."

Deep Dives

A Real Linux Desktop in the Canvas Copy Chapter

Agent Zero opens its own Linux desktop inside the right-side Canvas. Not a remote VM, not a shared clipboard, but a real XFCE desktop session running in the container.

That means the agent can drive real desktop software: open Blender to model a 3D object, jump into a terminal window, manage files visually, run a GUI tool that has no API.

You watch every action, and you can intervene at any moment because your mouse and keyboard share the same desktop.

See the Desktop guide for the walkthrough, prompt examples, and how Desktop differs from Browser.

Native Browser With DOM Annotations Copy Chapter

Agent Zero ships a built-in Browser with an optional live surface in the Canvas. The agent can open pages, read them, click, type, upload files, and take screenshots - the usual. The unusual part is Annotate mode.

Annotate mode turns any webpage into an interactive directive surface. Click an element to:

• Change it - "make this button blue and round the corners" runs as a JS instruction the agent applies and verifies.
• Inspect it - pull the DOM, the styles, the parent chain, the framework hints into the conversation.
• Lift it - see a card, hero, or component on someone else's site that you like? Capture it and have the agent re-implement it in your own project's stack.
• Comment it - leave actionable notes pinned to elements during a UI review; the agent reads the comments and ships the fixes.

The Docker browser is the default live Browser surface. Browser history keeps screenshots of important steps, so older chats can still show what the agent saw. The Browser also supports Chrome extensions inside the Docker browser, and Bring Your Own Browser through the A0 CLI Connector lets the agent drive Chrome, Edge, Brave, Opera, Vivaldi, or Chromium on your own machine.

See the Browser guide for screenshots, settings, host-browser setup, and troubleshooting.

Cowork on Documents Copy Chapter

Markdown Editor With Live Cowork Copy Section

The Canvas includes a rich Markdown editor designed for genuine cowork. Ask the agent to "write a plan to do X in a TODO.md in the open doc" and you'll see the file appear in the editor, character by character, while you keep typing in another section.

It's not a preview pane. It's a real editor with toolbar, formatting buttons, tables, and an editable source view - built so that the agent's edits and yours are equal first-class operations on the same document.

Use it for plans, TODOs, meeting notes, RFCs, project handoffs, or any artifact where the deliverable should live as text rather than be trapped inside chat scrollback.

LibreOffice Integration Copy Section

LibreOffice Writer, Calc, and Impress are wired up so you can type by hand while Agent Zero creates, updates, saves, and verifies the same files in real time.

ODT, ODS, and ODP binary formats are first-class citizens in the Agent Zero Desktop environment to align with the Open Document Format (ODF).

Use the Desktop toolbar to create and edit Writer, Spreadsheet, and Presentation LibreOffice files.

Plugin Hub - 100+ Community Plugins Copy Chapter

Agent Zero is built for extension, not just configuration. The built-in Plugin Hub browses a growing catalog of community plugins - currently more than 100, covering:

• Development frameworks like the BMAD Method (full software development lifecycle with 20 specialist agents) and Agent Skills.
• Memory systems - alternative memory backends, intelligent consolidation strategies, vector recall plugins.
• Tools and integrations - embedded terminals, custom browsers, deployment helpers, API clients.
• UI extensions - chat rename controls, sidebar tweaks, theme packs, custom Canvas panels.
• Workflow plugins - schedulers, multi-agent orchestration, project automations.

Install with a click from the Web UI, or publish your own to the index repository. Combined with custom prompts in prompts/, custom tools in tools/, MCP servers, A2A connectors, and project-scoped configuration, Agent Zero gives you a real surface area to shape the agent into whatever you need.

See the Skills guide, the Create a Small Plugin tutorial, and the MCP setup guide.

Use Your OpenAI Codex Plan Copy Chapter

Agent Zero connects to your OpenAI Codex plan through the new OAuth flow. Sign in with your account, pick the Codex-backed provider, and let Agent Zero use the plan you already have. Click "Connect", enter the device code in the OpenAI page, choose your model, and you're set.

This is the first step toward account-backed LLM plans in Agent Zero. More integrations are coming, including Gemini CLI and Claude Code through extra-usage.

A0 CLI Connector: Extend Onto Your Host Machine Copy Chapter

The A0 CLI Connector is not a separate CLI agent. It connects to a running Agent Zero instance and gives that instance a terminal-native bridge to your host machine - so the same agent (with all its memory, projects, and skills) can also work on real files outside the Docker container.

Install the connector on the machine you want Agent Zero to work on, not inside the Agent Zero container.

macOS / Linux Copy Section

curl -LsSf https://cli.agent-zero.ai/install.sh | sh

Windows PowerShell Copy Section

irm https://cli.agent-zero.ai/install.ps1 | iex

Then run a0 to connect your terminal to an existing Agent Zero instance. It can usually discover a local instance automatically, or you can point it at a remote URL hosted somewhere else, such as a VPS or tunnel.

This is especially useful if you:

• prefer CLI workflows;
• want Agent Zero to work in an existing local repository;
• are running Agent Zero on a remote server;
• want Docker isolation for Agent Zero while still granting explicit, controlled access to host-side work.

For full setup, see the A0 CLI Connector guide (or the in-repo guide).

Projects, Skills, Agent Profiles, and Model Presets Copy Chapter

Projects isolate workspaces, instructions, memory, secrets, knowledge, repositories, and model-preset choices. Clone a public or private Git repo into a project and give the agent context that belongs to that work alone.

Skills can be loaded on demand by Agent Zero, or pinned from the chat input when you want a specific procedure to stay active.

Agent Profiles change the broader working style of the current chat.

Model Presets are named shortcuts for model setups, so you can quickly switch between fast, balanced, cheap, local, or high-power model choices.

Multi-Agent Cooperation Copy Chapter

Every agent can create subordinate agents to break down work. The superior gives tasks and receives reports; subagents keep their own contexts focused and return their findings when done.

This makes Agent Zero useful for research, software engineering, data analysis, plugin development, and tasks where several specialized perspectives are better than one overloaded context.

Transparent and Extensible by Design Copy Chapter

Almost nothing is hidden. Prompts live in prompts/, tools live in tools/ or plugins, and built-in behavior can be inspected, changed, replaced, or extended.

Agent Zero supports plugins, MCP, A2A, custom tools, custom prompts, project-scoped configuration, environment-based deployment settings, and a Web UI designed to keep the agent's work readable in real time.

Time Travel Copy Chapter

Time Travel gives Agent Zero-owned /a0/usr workspaces snapshot history, diff inspection, travel, and revert. It is designed for recoverable agent work: see what changed, compare files, inspect a past state, and roll back when needed.

It is not a replacement for Git or backups. It is a practical safety layer for the workspace where agents are actively creating and editing files.

Real-World Use Cases Copy Chapter

• Software engineering: inspect a codebase, make scoped edits, run tests, explain tradeoffs, and keep a recoverable history of file changes.
• Host-machine development: connect with a0 and let Agent Zero work in your real local repositories, or clone them through Git Projects feature in the Web UI.
• Design inspiration and UI iteration: browse the web, annotate elements you like, and pull components into your own stack.
• Financial analysis and charting: collect data, correlate events, create spreadsheets, and generate editable charts.
• Office deliverables: cowork on documents, spreadsheets, and presentation decks instead of trapping the result in chat text.
• Web and mobile QA: browse an app, annotate UI issues, install browser extensions, and turn visual comments into actionable fixes.
• API integration: paste an API snippet, let the agent build a working example, and store the pattern for future use.
• Client/project isolation: keep memory, secrets, instructions, files, and model choices separated by project.
• Scheduled operations: run recurring checks and monitoring tasks with project-scoped context and credentials.

Documentation Copy Chapter

Build With Us Copy Chapter

Agent Zero is built for people who want to understand and shape their tools.

You can help by improving docs, creating skills, publishing plugins, testing model/provider setups, reporting bugs, sharing workflows, or contributing core improvements. Start with the Contributing guide, browse the Plugin Hub, or bring ideas to Discord.

Community and Support Copy Chapter

• Discord for live discussion and help.
• Skool Community for community learning.
• YouTube for demos and tutorials.
• X, LinkedIn, and Warpcast for updates.
• GitHub Issues for bugs and feature requests.

Space Agent is the related, more polished product direction for the agent-shaped workspace. Agent Zero remains the open framework and Linux-powered workbench.

Safety Model Copy Chapter

Agent Zero is powerful because it can use a real environment.

• Keep it running inside Docker or another isolated environment.
• Do not mount your entire home directory unless you understand the risk.
• Grant A0 CLI Read+Write access and remote code execution only for machines and workspaces you trust.
• Store credentials in project secrets or settings, not in prompts or public files.
• Review actions that touch accounts, money, production systems, or private data.
• Keep backups for important workspaces.

File: docs/guides/a2a-setup.md Copy Chapter

A2A Server Setup

Agent Zero can communicate with other Agent Zero instances using the A2A (Agent-to-Agent) protocol based on FastA2A. This guide shows you how to enable and configure A2A connectivity through the Settings UI.

What is A2A? Copy Chapter

A2A enables direct communication between multiple Agent Zero instances. This allows:

• Distributed workflows - Delegate tasks to specialized agent instances
• Context isolation - Maintain separate workspaces for different agents
• Long-running collaboration - Persistent agent-to-agent conversations
• Project-specific delegation - Route work to agents with specific project contexts

[!NOTE]
This guide covers enabling Agent Zero as an A2A server. For API-level integration details, see the advanced connectivity documentation.

Enabling the A2A Server Copy Chapter

Step 1: Open A2A Configuration Copy Section

1. Click Settings in the sidebar
2. Navigate to the MCP/A2A tab
3. Scroll to the A0 A2A Server section
4. Toggle Enable A2A server to ON

Step 2: Get Connection URL Copy Section

1. Click on connection example to view your A2A connection details
2. The dialog displays:
   • API Token - Automatically generated from your username and password
   • A2A Connection URL - The full URL other agents will use to connect
   • Optional Project selector - To create project-specific connection URLs

Step 3: Save Configuration Copy Section

1. Click Save to apply your settings
2. The A2A server is now active and ready to accept connections

[!IMPORTANT]
The API token changes when you update your Agent Zero credentials. Existing connections will need to be reconfigured with the new token.

Connection URL Format Copy Chapter

The basic A2A connection URL follows this format:

http://YOUR_HOST:PORT/a2a/t-YOUR_API_TOKEN

With Project Context Copy Section

To connect with a specific project active:

http://YOUR_HOST:PORT/a2a/t-YOUR_API_TOKEN/p-PROJECT_NAME

When a project is specified:

• All A2A conversations run in that project's context
• The agent has access to project-specific resources and knowledge
• Enables isolated, project-focused agent collaboration

Example Use Cases Copy Chapter

1. Local Development Setup Copy Section

Two Agent Zero instances on the same machine:

Instance 1: http://localhost:8080/a2a/t-abc123xyz
Instance 2: http://localhost:8081/a2a/t-def456uvw

2. Remote Agent Collaboration Copy Section

Connect to a remote Agent Zero instance:

http://agent.example.com:8080/a2a/t-remote-token

3. Project-Specific Delegation Copy Section

Main agent delegates frontend work to specialized agent:

http://localhost:8081/a2a/t-frontend-token/p-webapp-ui

Docker Networking Copy Chapter

If running Agent Zero in Docker:

• Same Host: Use host.docker.internal:PORT (macOS/Windows) or container networking (Linux)
• Different Hosts: Use the public IP or domain name of the target instance
• Port Mapping: Ensure the Agent Zero port is exposed in your Docker configuration

Security Considerations Copy Chapter

• Token Protection: Keep your API tokens secure - they provide full access to your Agent Zero instance
• Network Access: Consider using firewalls or reverse proxies to restrict A2A endpoint access
• HTTPS: For production deployments, use HTTPS to encrypt A2A communication
• Credential Rotation: Changing your password will invalidate all existing A2A connection URLs

Testing Your Connection Copy Chapter

You can test A2A connectivity using curl:

curl -X POST http://localhost:8080/a2a/t-YOUR_TOKEN \
  -H "Content-Type: application/json" \
  -d '{"message": "Hello from another agent"}'

A2A vs MCP Copy Chapter

[!TIP]
Use A2A when you need another agent's reasoning and conversation capabilities. Use MCP when you just need access to specific tools or functions.

Troubleshooting Copy Chapter

Connection Refused Copy Section

• Verify the A2A server is enabled in Settings
• Check that the Agent Zero instance is running
• Confirm the port is accessible (check firewall rules)

Invalid Token Copy Section

• Token may have changed due to credential updates
• Generate a new connection URL from Settings > MCP/A2A
• Update the connecting agent's configuration

Project Not Found Copy Section

• Verify the project name in the URL matches exactly
• Check that the project exists in the target instance
• Project names are case-sensitive

Advanced Configuration Copy Chapter

For detailed A2A protocol specifications, API examples, and integration patterns, see the Advanced Connectivity Guide.

File: docs/guides/api-integration.md Copy Chapter

Adding External APIs Without Code

One of Agent Zero's most powerful capabilities is the ability to integrate external APIs on the fly without writing any code. By simply providing API documentation or code snippets, the agent can learn to use new services and remember how to use them in future conversations.

This tutorial demonstrates how to integrate Google's image generation API from Google AI Studio - but the same process works for any public API.

How It Works Copy Chapter

Agent Zero can:

1. Analyze API code - Understand how to use an API from provided snippets or documentation
2. Execute the integration - Run the code to accomplish your task
3. Remember the solution - Store the approach in its memory for future use
4. Manage credentials - Use secrets stored globally or per-project for authentication

This means you can add capabilities like image generation, translation services, payment processing, or any other API-based feature simply by showing the agent how it works once.

Example: Image Generation with Google AI Studio Copy Chapter

Let's walk through adding image generation capabilities using Google's Gemini API.

Step 1: Get the API Code Copy Section

First, we need the code snippet that shows how to use the API.

1. Go to Google AI Studio
2. Use the interface to create or test an image generation prompt
3. Click "Get Code" in the UI
4. Select "Python" as the language
5. Download the code file (or copy it to clipboard)

[!TIP]
Most API platforms (OpenAI, Anthropic, Replicate, etc.) provide similar "Get Code" features or have documentation with ready-to-use snippets.

Step 2: Provide the Code to Agent Zero Copy Section

Now we'll tell Agent Zero to use this code:

1. Open a chat with Agent Zero
2. Send a message like: "Use this code to generate an image of the Agent Zero logo"
3. Either:
   • Attach the downloaded Python file, or
   • Paste the code snippet into the chat

Agent Zero will analyze the code and understand:

• What dependencies are needed (google-genai package)
• How to structure the API request
• What parameters are required
• How to handle the response

Step 3: Configure API Credentials Copy Section

On first run, Agent Zero will attempt to use the API but discover it needs an API key:

Agent Zero will tell you:

• What credential is missing (e.g., GEMINI_API_KEY)
• Where to configure it (Settings → External Services or Project settings)

Adding the API Key

You have two options for storing credentials:

Option 1: Global Secrets (available to all chats and projects)

1. Click the Settings icon in the sidebar
2. Go to External Services
3. Add a new line: GEMINI_API_KEY=your_actual_key_here
4. Click Save

Option 2: Project Secrets (available only within a specific project)

1. Open your project settings
2. Go to the Secrets tab
3. Add the key-value pair
4. Save the project

[!NOTE]
Global secrets are ideal for APIs you use frequently across different projects. Project secrets are better for client-specific or project-specific integrations.

Step 4: Generate the Image Copy Section

After configuring the API key, tell Agent Zero to proceed:

"I set the API key in secrets. Now you can use it."

Agent Zero will:

1. Retrieve the API key from secrets
2. Install required dependencies (google-genai package)
3. Execute the image generation code
4. Save the generated image to disk
5. Report the file location

The agent confirms:

• Mission complete
• File location: /root/agent_zero_logo_0.jpg
• File size: 378 KB

How Memory Helps Copy Chapter

Agent Zero can save useful API patterns in memory so you do not have to explain
the same integration every time.

For example, it may remember:

• what the API is useful for;
• what credential name is needed;
• which package or example worked;
• how you prefer to use that service in this project.

[!IMPORTANT]
Memory still needs curation. If Agent Zero keeps using an old API pattern,
wrong credential name, or outdated package, open Memory and fix or remove that
memory. Memory should help the agent think, not trap it in yesterday's answer.

See the Memory Guide for cleanup and curation tips.

Use Cases Copy Chapter

This approach works for any external API. Common examples:

Communication & Notifications Copy Section

• SendGrid: Email delivery
• Twilio: SMS and phone calls
• Slack/Discord: Message webhooks
• Telegram: Bot interactions

Data & Analytics Copy Section

• Google Sheets API: Spreadsheet automation
• Airtable: Database operations
• Stripe: Payment processing
• Plaid: Banking data

Content & Media Copy Section

• Unsplash/Pexels: Stock photos
• ElevenLabs: Text-to-speech
• Whisper API: Speech-to-text
• Stable Diffusion: Image generation
• Replicate: Various AI models

Development Tools Copy Section

• GitHub API: Repository management
• Jira/Linear: Issue tracking
• Vercel/Netlify: Deployment
• Docker Hub: Container registry

Specialized Services Copy Section

• WeatherAPI: Weather data
• Google Maps: Geocoding, directions
• Currency exchange: Forex rates
• Translation APIs: Multi-language support

Best Practices Copy Chapter

1. Start with Official Examples Copy Section

Always use code snippets from official documentation or API providers' "Get Code" features. These are:

• Tested and working
• Up-to-date with latest API versions
• Include proper error handling
• Show recommended practices

2. Organize Credentials Copy Section

For personal/global APIs:

• Store in Settings → External Services
• Use clear naming: SERVICE_API_KEY, SERVICE_SECRET
• Add comments to document what each key is for

For project-specific APIs:

• Store in Project Settings → Secrets
• Keeps client data isolated
• Prevents accidental cross-project usage

3. Document in Project Instructions Copy Section

When integrating APIs for a specific project, add notes to the project instructions:

## Available APIs

This project has access to:

- **Gemini Image Generation**: Use for creating visuals and illustrations
  - Credentials: GEMINI_API_KEY (configured in project secrets)
  - Best for: Professional graphics, concept art, UI mockups

- **SendGrid Email**: Use for sending automated emails
  - Credentials: SENDGRID_API_KEY
  - Best for: Notifications, reports, customer communications

This helps the agent understand what tools are available for the current project.

Advanced: Custom API Wrappers Copy Chapter

For APIs you use frequently, you can have Agent Zero create reusable wrapper functions:

"Create a Python module called image_gen.py with a function generate_image(prompt, style='professional') that uses the Gemini API. Include error handling and save the image to the current project folder."

Agent Zero will:

1. Create a clean, reusable module
2. Add proper documentation
3. Include error handling
4. Make it easy to call from future tasks

Then in future chats:

"Use the image_gen module to create a logo", and it just works!

Conclusion Copy Chapter

By showing Agent Zero a working API example, you can:

• add a new service to a project;
• keep credentials in settings or project secrets;
• reuse working patterns later;
• clean up memory when an old pattern stops helping.

This is not magic permanence. It works best when you keep the example, secrets,
project instructions, and memories tidy.

Related Copy Chapter

• Memory Guide
• Projects Guide
• MCP Setup

File: docs/guides/contribution.md Copy Chapter

Contributing to Agent Zero

Contributions to improve Agent Zero are very welcome! This guide outlines how to contribute code, documentation, or other improvements.

Getting Started Copy Chapter

• See Development Setup for a local development environment.
• See Create a Small Plugin before building a new plugin.
• Use DeepWiki for Agent Zero for architecture and source-linked internals.

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).

Making Changes Copy Chapter

• Code Style: Follow the existing code style. Agent Zero generally follows PEP 8 conventions.
• Documentation: Update the documentation if your changes affect user-facing functionality. The documentation is written in Markdown.
• Commit Messages: Write clear and concise commit messages that explain the purpose of your changes.

Submitting a Pull Request Copy Chapter

1. Push Your Branch: Push your branch to your forked repository on GitHub.
2. Create a Pull Request: Create a pull request from your branch to the appropriate branch in the main Agent Zero repository.
   • Search open and recently closed upstream PRs for overlapping work before opening a new one.
   • Target the branch currently used for comparable active upstream contributions or explicit maintainer guidance. Do not assume development is always correct.
   • Keep the source branch available on your fork until the pull request is merged or intentionally closed.
3. Provide Details: In your pull request description, clearly explain the purpose and scope of your changes. Include relevant context, test results, and any other information that might be helpful for reviewers.
4. Address Feedback: Be responsive to feedback from the community. We love changes, but we also love to discuss them!

Working With Forks Safely Copy Chapter

When contributing from a fork, prefer the standard GitHub flow:

1. Fork the repository publicly if the branch may become the head branch of an upstream pull request.
2. Add an upstream remote that points to agent0ai/agent-zero.
3. Sync your fork regularly before starting new work so your branch starts from the current upstream target branch.
4. Create one focused branch per change (for example, one bugfix, one plugin, or one docs update).
5. Open the pull request across forks by explicitly selecting the upstream base repository/branch and your fork/compare branch.

If your fork contains GitHub Actions workflows, be careful with GitHub's "Allow edits and access to secrets by maintainers" option. Only enable it when you are comfortable with maintainers editing workflow files on the fork branch.

Choosing The Right Publication Path Copy Chapter

• Core bugfixes and docs for Agent Zero itself: prepare them in a clean fork/clone of agent-zero and open a PR back to the upstream repository.
• Community plugins: publish the plugin in its own public repository, then submit it to agent0ai/a0-plugins.
• Skills: develop locally in usr/skills/, then move stable skills to skills/ for Agent Zero contributions or publish them in a dedicated public repository/collection.
• Private experiments, credentials, local R&D, or customer-specific assets: keep them out of public forks and upstream pull requests.

For a contributor-focused decision guide that covers fixes, plugins, skills, and
what should stay private, see Sharing and Safety.

Documentation Stack Copy Chapter

• Write local docs for practical setup, screenshots, and user workflows.
• Point architecture and deep internals to DeepWiki.
• Use GitHub Flavored Markdown when it helps: tables, task lists, callouts, and fenced code blocks.

File: docs/guides/mcp-setup.md Copy Chapter

MCP Setup

MCP lets Agent Zero use tools from other apps and services.

Think of each MCP connection as a bridge. One bridge might connect Gmail,
another might connect a database, and another might connect an automation app.

Use MCP when you have a clear external tool you want Agent Zero to call. For
normal browsing, start with Agent Zero's built-in Browser first.

[!NOTE]
This page is about giving Agent Zero tools from other apps. For deeper MCP
details, see the advanced MCP reference.

When To Use MCP Copy Chapter

Before You Add One Copy Chapter

• You know what app or service you want to connect.
• You trust the package or URL.
• You know where it will run: inside Agent Zero, on your computer, or online.
• You have any needed credentials ready.
• You know whether the tool should be project-specific or global.

Open MCP Settings Copy Chapter

1. Click Settings in the sidebar.
2. Open the MCP/A2A tab.
3. Find External MCP Servers.
4. Click Open.

Add A Connection Copy Chapter

The configuration editor accepts JSON. A command-based MCP connection looks like
this:

{
  "mcpServers": {
    "chrome-devtools": {
      "command": "npx",
      "args": ["-y", "chrome-devtools-mcp@latest"]
    }
  }
}

Click Apply now after editing.

[!TIP]
The first launch of an npx or uvx server can take a little longer because
the package may need to download.

Check That It Connected Copy Chapter

After applying the config, look for the status below the editor.

After the connection works, Agent Zero discovers the MCP tools. The active
Agent Profile's MCP policy still decides which discovered tools it may use. Use
Edit agent -> MCPs to keep the category default or set an individual tool
to On or Off. See Agent Profiles.

You can still ask naturally:

Use the connected Gmail tools to find the last message from Alice and summarize it.

Common Examples Copy Chapter

Tool Started By A Command Copy Section

Use this pattern when Agent Zero should start the tool itself.

{
  "mcpServers": {
    "sqlite": {
      "command": "uvx",
      "args": ["mcp-server-sqlite", "--db-path", "/root/db.sqlite"]
    }
  }
}

Tool At A URL Copy Section

Use this pattern when the tool is already running at a URL.

{
  "mcpServers": {
    "external-api": {
      "url": "https://api.example.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

[!IMPORTANT]
Do not paste real API keys into public files, screenshots, or issue reports.
Prefer project secrets or environment variables when possible.

Docker Networking Copy Chapter

If Agent Zero runs in Docker and the MCP tool runs somewhere else, the address
matters.

On Linux, host.docker.internal is not always available by default. Running the
MCP tool in the same Docker network is usually cleaner.

Browser MCP Or Built-In Browser? Copy Chapter

For most browsing tasks, use Agent Zero's built-in _browser plugin and direct
browser tool. It covers the Docker browser surface, screenshots, annotations,
Chrome extensions, and optional A0 CLI host-browser mode.

MCP-based browser tools are still useful when another browser tool is required
for a specific workflow.

See the Browser Guide for the built-in workflow.

Recommended Server Types Copy Chapter

Troubleshooting Copy Chapter

• No tools appear: confirm the JSON is valid and click Apply now again.
• Command not found: install the command where Agent Zero can run it, or use a URL-based tool instead.
• Package launch is slow: wait for the first package download to finish.
• Host service unreachable: check Docker networking and try host.docker.internal on macOS or Windows.
• Credentials fail: rotate or re-enter the credential, then restart or reapply the config.

Related Copy Chapter

• Browser Guide: built-in browsing, screenshots, annotations, Docker browser, and host-browser mode.
• A0 CLI Connector: host-machine access and Bring Your Own Browser setup.
• Advanced MCP Configuration: complete configuration reference.

File: docs/guides/projects.md Copy Chapter

Projects

Projects tell Agent Zero what world it is working in.

Use a project when you want a chat to have its own purpose, instructions, files,
memory, secrets, and model choices. A project can be a client, a codebase, a
research topic, a recurring workflow, or any other focused workspace.

When To Use One Copy Chapter

Create a project when you want Agent Zero to remember context that should not
leak into every other chat.

Good project examples:

• A Git repository you want Agent Zero to work on.
• A client workspace with its own tone, files, and credentials.
• A research topic with its own sources and notes.
• A recurring report that always follows the same steps.
• A documentation workspace with a clear writing style.

Stay in a normal chat when the task is quick, disposable, or unrelated to a
larger body of work.

Open Projects Copy Chapter

From the dashboard, click Projects.

If you have no projects yet, the list starts empty and offers Create
project.

Create A Project Copy Chapter

Click Create project and give it a clear title. The title is what you will
recognize later in the project picker.

For a simple project, the title is enough. If you want Agent Zero to clone a
repository into the project, paste the Git URL in Git Repository before you
continue.

After creating the project, Agent Zero opens the edit screen.

Write Helpful Instructions Copy Chapter

The most important part of a project is the Instructions field.

Description answers: "What is this project?"

Instructions answer: "How should Agent Zero behave when this project is active?"

Good instructions are usually short and specific. Tell Agent Zero:

• what the project is for,
• what style of answer you want,
• where files should be read or written,
• what quality rules matter,
• when it should ask before acting.

Example:

You are working inside the Docs Example Workspace.

Use this project for small documentation examples and user-facing guidance.

When this project is active:
- Explain steps in plain language before technical detail.
- Prefer screenshots, checklists, and concrete examples.
- Keep generated files inside this project unless I ask otherwise.
- Ask before using credentials, private data, or external accounts.
- When editing docs, focus on what the user sees and what they should do next.

That is enough. A project prompt does not need to be a constitution. Start small,
then improve it when you notice what the agent should do differently.

Activate A Project Copy Chapter

Open or create a chat. In the top-right corner, click the project picker. It may
say No project if the chat is not attached to a project yet.

Choose your project.

When the project name appears in the top bar, the chat is now using that
project. Agent Zero will use the project instructions and work with the project
workspace for that chat.

Each chat can use a different project. This lets you keep a client chat, a code
chat, and a research chat separate at the same time.

Projects can also own Agent Profile overrides and availability. In Manage
agents, select a project before editing or turning a profile off; the Global
profile remains unchanged. See Agent Profiles.

What Changes After Activation Copy Chapter

When a project is active, Agent Zero can use:

• the project instructions,
• files stored in the project workspace,
• project memory,
• project variables and secrets,
• project-specific model settings when configured.

Try prompts like:

Read the project instructions and tell me how you will work in this workspace.

Create a short README for this project based on its current files.

Use this project as the home for our weekly research notes.

Git Projects Copy Chapter

If you paste a Git repository URL while creating the project, Agent Zero clones
that repository into the project workspace.

Use Git projects when you want Agent Zero to work on a real codebase with the
right local files, branch state, and project instructions.

For private repositories, use a token when the UI asks for one. Do not paste
tokens into chat messages.

Variables And Secrets Copy Chapter

Projects can store values that only make sense inside that workspace.

Use variables for non-sensitive settings, such as:

REPORT_FORMAT=markdown
DEFAULT_REGION=eu-west

Use secrets for credentials, such as API keys and passwords. Refer to them by
name in chat:

Use the project GITHUB_TOKEN to check the repository status.

Keep your own copy of important secrets. Backups may not include every secret.

Keep Projects Tidy Copy Chapter

A good project stays useful because it stays focused.

• Use a clear title.
• Keep instructions short enough to read.
• Store files where the project expects them.
• Keep secrets scoped to the project that needs them.
• Update instructions when your workflow changes.
• Create a new project when the work belongs to a different client, codebase, or topic.

Common Problems Copy Chapter

Agent Zero ignores the project.
Check the top-right project picker. The project name must be visible in the
active chat.

The project instructions are wrong or stale.
Open Projects, click the edit icon, update the instructions, and save.

A Git repository did not clone.
Check the URL, authentication token, and network access. For private repos,
create a fresh token and try again.

Secrets are not being used.
Make sure the secret is saved in the project and refer to it by exact name.

The project has become too broad.
Split it. Projects work best when each one has a clear job.

Related Copy Chapter

• Usage Guide
• Browser Guide
• A0 CLI Connector
• DeepWiki for Agent Zero

File: docs/guides/troubleshooting.md Copy Chapter

Troubleshooting and FAQ

This page addresses frequently asked questions (FAQ) and provides troubleshooting steps for common issues encountered while using Agent Zero.

Frequently Asked Questions Copy Chapter

1. How do I ask Agent Zero to work directly on my files or dirs?

• Place the files/dirs in /a0/usr. Agent Zero will be able to perform tasks on them.

2. When I input something in the chat, nothing happens. What's wrong?

• Check if you have set up API keys in the Settings page. If not, the application cannot call LLM providers.

3. I get "Invalid model ID." What does that mean?

• Verify the provider and model naming. For example, openai/gpt-5.3 is correct for OpenRouter, but incorrect for the native OpenAI provider, which goes without prefix.

4. Does ChatGPT Plus include API access?

• No. ChatGPT Plus does not include API credits. You must provide an OpenAI API key in Settings.

5. Where is chat history stored?

• Chat history lives at /a0/usr/chats/ inside the container.

6. How do I integrate open-source models with Agent Zero?
Refer to the Choosing your LLMs section for configuring local models (Ollama, LM Studio, etc.).

[!TIP]
Some LLM providers offer free usage tiers, for example Groq, Mistral, SambaNova, or CometAPI.

7. How can I make Agent Zero retain memory between sessions?
Use Settings -> Backup & Restore and avoid mapping the entire /a0 directory. See How to update Agent Zero.

8. My browser tool fails or says Chromium is missing. What now?

In normal Docker installs, the Browser already includes what it needs.

If you are running a local development checkout, Agent Zero can install the
browser the first time it is needed. To install it ahead of time, run this from
the project root after installing Python requirements:

PLAYWRIGHT_BROWSERS_PATH=tmp/playwright patchright install chromium --no-shell

If Bring Your Own Browser mode fails:

• keep A0 CLI connected to the chat;
• restart or reconnect A0 CLI after enabling remote debugging in a browser;
• run /browser status in A0 CLI;
• check that Browser settings still say Bring Your Own Browser;
• check Page content access if page text or screenshots are blocked.

See the Browser Guide for Browser settings and host-browser
behavior. If you need a different external browser tool, see
MCP Setup.

9. My secrets disappeared after a backup restore.
Secrets are stored in /a0/usr/secrets.env and are not always included in backup archives. Copy them manually.

10. Where can I find more documentation or tutorials?

• Join the Agent Zero Skool or Discord community.

11. How do I adjust API rate limits?
Use the model rate limit fields in Settings, under the Main Model and Utility
Model sections, to set request, input, and output limits.

12. My code_execution_tool doesn't work, what's wrong?

• Ensure Docker is installed and running.
• On macOS, grant Docker Desktop access to your project files.
• Verify that the Docker image is updated.

13. Can Agent Zero interact with external APIs or services (e.g., WhatsApp)?
Yes. Start with API Integration for one-off services or
MCP Setup when the service already has MCP support.

Troubleshooting Copy Chapter

Installation

• Docker Issues: If Docker containers fail to start, consult the Docker documentation and verify your Docker installation and configuration. On macOS, ensure you've granted Docker access to your project files in Docker Desktop's settings as described in the Installation guide. Verify that the Docker image is updated.
• Web UI not reachable: Ensure at least one host port is mapped to container port 80. If you used 0:80, check the assigned port in Docker Desktop.

Usage

• Terminal commands not executing: Ensure the Docker container is running and properly configured. Check SSH settings if applicable. Check if the Docker image is updated by removing it from Docker Desktop app, and subsequently pulling it again.
• Agent Zero stuck on the update screen or not starting after an update: If the browser stays on the updating screen for multiple minutes, reload the current browser window first. If the UI still does not come back, restart the Docker container. If it still does not recover, queue another self-update for the next startup and inspect the updater log.

From the host, find the container name:

docker ps

Open a shell inside the container:

docker exec -it <container> /bin/bash

Queue an update for the next startup attempt with the recovery script in /exe:

/exe/trigger_self_update.sh

That default command writes /exe/a0-self-update.yaml with main and latest, so the next startup tries the newest release in the current installed major version. You can also specify the branch, version, and backup settings:

/exe/trigger_self_update.sh ready latest
/exe/trigger_self_update.sh main v1.10 --backup-dir /root/update-backups --backup-name usr-recovery.zip
/exe/trigger_self_update.sh development latest --no-backup

You can run the same commands directly from the host without opening a shell:

docker exec -it <container> /exe/trigger_self_update.sh
docker exec -it <container> /exe/trigger_self_update.sh ready latest
docker exec -it <container> tail -n 200 /exe/a0-self-update.log
docker exec -it <container> cat /exe/a0-self-update-status.yaml

The recovery command only schedules the update. Restart the container or let Agent Zero start again, then check /exe/a0-self-update.log and /exe/a0-self-update-status.yaml to see what happened.

• Error Messages: Pay close attention to the error messages displayed in the Web UI or terminal. They often provide valuable clues for diagnosing the issue. Refer to the specific error message in online searches or community forums for potential solutions.

• Performance Issues: If Agent Zero is slow or unresponsive, it might be due to resource limitations, network latency, or the complexity of your prompts and tasks, especially when using local models.

File: docs/guides/usage.md Copy Chapter

Usage Guide

This guide is the practical tour of Agent Zero after installation. It explains
what you can do in the Web UI, what to try first, and where to go when you want
the deeper source-linked explanation.

For architecture, backend flow, Web UI internals, plugin lifecycle, and API
details, use DeepWiki for Agent Zero.

Basic Operations Copy Chapter

Agent Zero is built around a chat, a working Linux environment, and a Web UI that
lets you watch and steer the work.

Common places to start:

• New Chat: start a clean conversation.
• Projects: give a chat its own workspace, files, memory, secrets, and instructions.
• Memory: review what Agent Zero has learned or imported.
• Tasks: create scheduled, planned, or manual automations.
• Files: open the Agent Zero file browser.
• Settings: configure models, credentials, preferences, plugins, and backup.
• Browser: open the live Browser surface when you want to watch browsing or annotate a page.
• Desktop: open the live Linux desktop when you want GUI apps, a terminal window, or LibreOffice Cowork.

The chat input also has action buttons for attachments, pausing, nudging, compacting,
and opening helpful views such as context or history.

Use Restart from the sidebar when you need the framework to reload after
settings or code changes.

Plugins And Plugin Hub Copy Chapter

Plugins add integrations, tools, panels, and automation helpers.

Open Plugins from the dashboard or sidebar to see what is installed.

Use the Browse tab or Install button to open the Plugin Hub.

Before installing a plugin, read its description, README, permissions, and source
link. Treat plugins like any other code you run in your workspace: install the
ones you trust and remove what you do not use.

When you want to make your own first plugin, start with something small and
visible. The Create a Small Plugin guide walks through a
local Web UI plugin that adds an unread dot to the chat list and then reviews it
with a0-review-plugin.

Skills, Agent Profiles, And Model Presets Copy Chapter

The small controls around the chat input let you shape the current conversation
without opening the full Settings screen.

Skills Copy Section

Skills are focused instructions Agent Zero can load when it needs them. You can
also pin a skill manually for the current chat.

Click the + button in the chat input, then click Skills.

Use the selector to add or remove active skills.

Active skills are added to the Protocol part of the prompt, so keep the
list short and intentional. See the Skills guide.

Agent Profiles Copy Section

Agent Profiles change the role, tone, and prompt instructions for the selected
chat.

Use the profile menu near the chat input to switch the current chat or edit a
profile. Select Manage agents to create, duplicate, reset, delete, or change
profile availability for Global or one project.

Use Settings -> Agent Config when you want to change the default profile for
new Global chats.

See the Agent Profiles guide.

Model Presets Copy Section

Model Presets are named shortcuts for model choices. Use them for setups like
Best, Balanced, Fast Cheap, or a model name you can spot quickly.

Click Edit presets when you want to add or rename presets.

See the Model Presets guide.

File Attachments Copy Chapter

Attach files when the agent should read, summarize, transform, or organize them.

You can attach one file or several files, then describe what should happen:

Read these PDFs and create a short comparison table.

Move these files into a clean folder structure and explain what changed.

Attached files are visible in the chat input before you send the message, so you
can remove mistakes before Agent Zero starts working.

Tool Usage Copy Chapter

You usually do not need to name tools. Say what you want done and Agent Zero will
choose whether it needs the browser, code execution, files, knowledge, plugins,
or another available capability.

Good prompts are specific about the desired result:

Research three deployment options for this app. Cite sources and finish with a recommendation.

Open the attached CSV, find the main trend, and create a chart I can edit later.

Inspect this repository and propose the safest first improvement before changing files.

When you do want internals, use
DeepWiki for Agent Zero.

Browser Tool And Surface Copy Section

The Browser has two parts:

• the browser tool, which the agent can call directly;
• the visible Browser surface in the Canvas, where you can watch and annotate pages.

Ask naturally:

Use the Browser tool to compare these pages and take screenshots of the important parts.

Open my local app in the Browser. I will annotate the page, then you can fix the issues.

For screenshots, history, annotations, Docker browser mode, host-browser mode
through A0 CLI, privacy controls, and Chrome extensions, see the
Browser Guide.

External browser MCP tools are still useful for specialized setups. See
MCP Setup.

Desktop Surface Copy Section

The Desktop surface opens Agent Zero's own Linux desktop in the Canvas.
Use it when you want the agent to work visually with GUI apps, open a terminal,
or cowork with you in LibreOffice.

The New menu can create Markdown, Writer, Spreadsheet, and Presentation
files. Writer, Calc, and Impress run inside the Desktop, so you can edit by hand
while Agent Zero creates, updates, saves, and verifies the same files.

For the screenshot walkthrough and prompt examples, see the
Desktop Guide.

Agent-To-Agent Communication Copy Section

Agent Zero instances can communicate through A2A when you want multiple
instances to collaborate.

Use A2A when you have a clear reason to split work across Agent Zero instances,
such as a specialist server, a remote machine, or a project-specific agent. See
A2A Setup.

Multi-Agent Cooperation Copy Section

Inside a single Agent Zero instance, the main agent can create subordinate agents
to investigate focused parts of a larger job.

This is useful for research, code review, comparison work, and tasks where one
agent should gather information while another keeps the main plan moving.

Projects Copy Chapter

Projects tell Agent Zero what world it is working in. Use one when a chat needs
its own files, instructions, memory, secrets, or model settings.

The simple flow:

1. Open Projects from the dashboard.
2. Click Create project.
3. Give it a clear title.
4. Add a short description.
5. Write practical instructions.
6. Save it.
7. Open a chat and choose the project from the top-right project picker.

Good project instructions tell Agent Zero what should be different in that
workspace:

When this project is active:
- Explain steps in plain language before technical detail.
- Prefer screenshots, checklists, and concrete examples.
- Keep generated files inside this project unless I ask otherwise.
- Ask before using credentials, private data, or external accounts.

Use projects for client work, code repositories, research topics, recurring
reports, and any workflow where context matters.

See the Projects guide for the full screenshot walkthrough.

Tasks And Scheduling Copy Chapter

Tasks let Agent Zero run work later, repeatedly, or on demand.

Use tasks for:

• morning or weekly reports;
• monitoring a source and summarizing changes;
• recurring cleanup or export jobs;
• project-specific checks;
• manual batch jobs you want to run again.

Open Tasks from the dashboard or sidebar.

When creating a task, focus on four things:

• Name: what you will recognize later.
• Type: scheduled, planned, or ad-hoc.
• Project: optional, but recommended when the task needs specific context or secrets.
• Prompt: the actual work Agent Zero should perform.

Example:

Name: Weekly docs review
Type: Scheduled
Project: Documentation
Prompt: Check the docs project for stale screenshots, broken links, and confusing sections. Summarize what needs attention.

Project-scoped tasks inherit project instructions, variables, secrets, files, and
memory. That means you can improve task behavior later by improving the project
instead of repeating every rule in every task.

Secrets And Variables Copy Chapter

Use Secrets for sensitive values such as API keys, tokens, passwords, and
credentials.

Use Variables for non-sensitive settings such as regions, URLs, usernames,
formats, or feature flags.

Refer to them by name in chat:

Use the project GITHUB_TOKEN to check repository status.

Do not paste credentials into chat messages or public files. Keep your own copy
of important secrets because backups may not include every secret.

Remote Access Via Tunneling Copy Chapter

Tunnels let you reach your local Agent Zero instance from another device or
share it temporarily.

Before creating a tunnel:

• set UI authentication;
• understand that anyone with the tunnel URL can try to open your instance;
• stop the tunnel when you no longer need it.

Open Settings -> External Services -> Flare Tunnel to create or stop a tunnel.

Voice Interface Copy Chapter

Agent Zero supports text-to-speech and speech-to-text through built-in voice plugins:

• _kokoro_tts provides container-side Kokoro speech synthesis when enabled.
• _whisper_stt provides local Whisper transcription and adds the microphone control when enabled.
• Browser-native speechSynthesis remains the fallback output path when _kokoro_tts is disabled.

Use the Voice section in Agent settings or the plugin settings in Agent Plugins to configure providers. Use the sidebar Speech preference when you want Agent Zero to read responses automatically.

Use speech when you want to listen while doing something else, dictate a prompt,
or make the interface more accessible.

Speech-to-text settings live in the Whisper STT plugin card and include model size, language code, voice message handling, silence threshold, and recording behavior. The microphone button appears in the chat input when _whisper_stt is enabled.

[!IMPORTANT]
Whisper STT and Kokoro TTS operate locally within the Docker/container runtime when their plugins are enabled.
Browser fallback TTS runs locally in the browser. No voice path requires OpenAI APIs.

Mathematical Expressions Copy Chapter

Agent Zero can render mathematical notation with KaTeX.

Ask for the format you want:

Solve this step by step and show the final equations in KaTeX.

File Browser Copy Chapter

The File Browser lets you inspect and manage files inside the Agent Zero
environment.

Use it to:

• upload files;
• download generated work;
• create folders;
• rename or delete files;
• open editable text files;
• inspect the project or /a0/usr workspace.

For file-based work, prefer /a0/usr or a project workspace. Avoid storing
important work only in temporary directories.

Memory Management Copy Chapter

Memory is where Agent Zero keeps useful remembered information from conversations
and imported knowledge. It is powerful, but it is not magic. Long-term AI memory
still needs curation; this is not fully solved even by the largest AI labs and
companies.

Open Memory when you want to search, review, edit, copy, or remove stored
entries.

The controls let you choose a memory directory, filter by area, set a result
limit, search, adjust match threshold, and clear filtered results.

Use memory deliberately:

• keep durable facts and useful patterns;
• remove old test data;
• edit memories that became inaccurate;
• use project memory for project-specific context;
• create a backup before large cleanup.

If Agent Zero does something unexpected, repeats a wrong behavior, or seems to
remember the wrong thing, Memory is one of the first places to look. A stale or
incorrect memory can poison the processing instead of helping it.

Click a memory row to inspect its full content and metadata. From the detail
view you can copy, edit, or delete the entry.

For a practical cleanup checklist, see the Memory Guide.

Backup And Restore Copy Chapter

Backups protect your chats, projects, knowledge, memory, settings, skills, and
workspace files.

Create a backup before:

• major updates;
• plugin experiments;
• bulk memory cleanup;
• moving to a new machine;
• deleting or reorganizing important project files.

Open Settings -> Backup & Restore to create or restore a backup.

Secrets are sensitive and may not always be included in backup archives. Keep a
separate secure copy of credentials you depend on.

Next Steps Copy Chapter

• Quick Start
• Projects guide
• Browser guide
• A0 CLI Connector
• Skills guide
• Agent Profiles guide
• Model Presets guide
• MCP Setup
• Troubleshooting
• DeepWiki for Agent Zero

File: docs/developer/architecture.md Copy Chapter

Architecture

Agent Zero architecture is now documented in
DeepWiki for Agent Zero.

Use DeepWiki when you want source-linked explanations of:

• the agent loop and message flow;
• Web UI internals;
• plugin discovery and lifecycle;
• projects, memory, tools, and scheduler internals;
• backend APIs and WebSocket behavior;
• deployment and runtime structure.

This local page intentionally stays short so the repository does not maintain a
second, stale architecture manual.

Practical Starting Points Copy Chapter

If you are changing core behavior, read the relevant DeepWiki page first, then
inspect the source in this repository before editing.

File: docs/developer/connectivity.md Copy Chapter

Connectivity

This page helps you choose the right connection path.

For source-linked architecture and endpoint internals, use
DeepWiki for Agent Zero. The local
docs should not duplicate the full connectivity architecture.

Choose The Right Path Copy Chapter

External API Basics Copy Chapter

You can find your API token in Agent Zero under Settings > External Services.

Common external endpoints include:

External API calls use the X-API-KEY header.

[!TIP]
For exact request and response details, check the current source or the
matching DeepWiki page. That keeps the API reference tied to the code that is
actually running.

MCP And A2A Copy Chapter

Use MCP when you want Agent Zero to call tools from another app or service.

Use A2A when you want another agent to talk to Agent Zero as a collaborator.

Both use the same Agent Zero instance and can be project-aware when configured
that way.

Related Copy Chapter

• A0 CLI Connector
• MCP Setup
• A2A Setup
• API Integration
• DeepWiki for Agent Zero