Agent Zero Setup Guide: Venice, Morpheus and Local Models

What Agent Zero is

Agent Zero is an open-source AI agent framework. It runs inside Docker, free software that keeps an app sealed in its own box (a container) on your computer. Inside that box the agent has its own Linux command line, where it writes and runs code, and it browses the web and keeps a memory between chats. The code is on GitHub at agent0ai/agent-zero, and the project’s own site is agent-zero.ai. The older frdel/agent-zero GitHub address now redirects to the new one.

Agent Zero doesn’t ship a model. You point it at one, and that choice decides who sees your prompts. This guide covers three private routes: Venice for hosted inferenceInferenceRunning a trained AI model to produce an answer. Inference is what happens when you type a prompt into ChatGPT and get a response. The model takes your input, computes a best guess, and returns it.Like asking an expert for their opinion. The training was the decades they spent becoming an expert. The inference is the 30 seconds it takes them to answer your specific question.Inference in the glossary →, the Morpheus marketplace through a gateway, and models running on your own machine.

I run Agent Zero every day in Docker on a Mac Studio, with scheduled jobs on several agent profiles. The settings below come from that install, read on 30 September 2026, apart from the hosted Morpheus gateway in Option A, which we haven’t run through Agent Zero ourselves.

Prerequisites

• Docker: Docker Desktop on a Mac or Windows, Docker Engine on Linux
• At least one model route: a Venice APIAPIApplication Programming Interface. A structured way for one piece of software to talk to another. In DeAI, APIs let applications request inference from a model without running the model themselves.Like a waiter in a restaurant. You don't walk into the kitchen and cook your own meal. You tell the waiter what you want, they tell the kitchen, the kitchen cooks it, and the waiter brings it back. The API is the waiter.API in the glossary → key, a Morpheus gateway key, or a local model server such as Ollama or LM Studio
• No GPUGPUGraphics Processing Unit. Originally designed to render video game graphics, GPUs turned out to be exceptionally good at the massively parallel math that AI models need. Modern AI training and inference runs almost entirely on GPUs.Like a factory with 10,000 workers doing the same simple task in parallel, versus a CPU which is more like 10 workers each doing different complex tasks. AI training involves doing simple math a million times per second on a million numbers, which is exactly what the GPU factory is designed for.GPU in the glossary →, unless you want to run the models locally too
• About 30 minutes

Step 1: Install Agent Zero

The easiest start is the project’s desktop app, the A0 Launcher, which checks Docker and sets Agent Zero up for you. If Docker already works, one command does the same job. Then open http://localhost:50001 in your browser.

docker run -d --name agent-zero \
  -p 50001:80 \
  -v ~/agent-zero-data:/a0/usr \
  --restart unless-stopped \
  agent0ai/agent-zero

Running it on a rented server (a VPS) instead? Bind the port to localhost with -p 127.0.0.1:50001:80 and reach the UI over an SSH tunnel (ssh -L 50001:localhost:50001 you@your-vps). The container has a shell and your API keys inside it, so it shouldn’t face the open internet.

Step 2: Choose your models

Current builds use three modelModelA trained neural network that takes inputs (text, images, audio) and produces outputs (more text, classifications, generated content). In DeAI the model is the thing that actually does the work.Like a very experienced apprentice who has spent years watching thousands of masters make furniture. They can't explain how they know when a joint is right, but they can make a chair that looks and functions like a Chippendale. The training is invisible. The output is what matters.Model in the glossary → roles, set under Settings → Agent Settings → Models. API keys go under Settings → External Services → API Keys.

That split puts the thinking on a larger hosted model and keeps the constant background chatter on our own hardware, where it costs nothing per token and never leaves the machine.

The provider dropdown includes Venice.ai, Ollama, LM Studio, llama.cpp, oMLX and Other OpenAI compatible, among others. For Venice, pick Venice.ai, paste your key and choose a model. Venice tags the models it hosts itself as Private and says it never stores those conversations, a claim we haven’t been able to verify independently. Our Venice review covers the full privacy model, including the gap between anonymised and confidential inference.

For a model on your own computer, remember the agent lives inside Docker’s box. From in there, your computer’s address is host.docker.internal, so Ollama sits at http://host.docker.internal:11434 and LM Studio at http://host.docker.internal:1234/v1. Agent Zero’s presets for both already use those addresses.

Not sure which route to pick? Here’s how we’d choose:

• Just trying it out? Venice. One key, fast, and it covers every role.
• Keeping sensitive work off the internet? A model on your own machine, if it has the memory to run one.
• Want the whole path on decentralised infrastructure? Morpheus, in Step 4.
• Want cost and privacy balanced? Our split: the main brain on Venice, the background chores local.

The dropdown also lists an Agent Zero API provider. Its configuration points at llm.agent-zero.ai and pulls its model list from Venice. We haven’t used it, so this guide goes direct.

Step 3: Test the agent

Start a new chat and give it a task that exercises the code tool:

Write a Python script that prints the SHA-256 hash of the string
"own your mind", run it, and report the output.

The agent plans the steps, writes the script, runs it in its own shell and reports back. If it stalls, open the logs (Troubleshooting, below) before changing models.

Step 4: Route inference through Morpheus (optional)

Instead of Venice, you can send the agent’s inference to the Morpheus compute network, where independent providers serve models and earn MOR. See our Morpheus Lumerin Node tutorial if you want to run the other side of this, providing compute rather than consuming it.

The hosted gateway is the quickest start. Your own Uplink gateway keeps the wallet and the proxy-router in your hands. Our agent-to-Morpheus hub compares every route and covers OpenClaw and Hermes too.

Option A: the hosted api.mor.org gateway

The Morpheus Inference API is an OpenAI-compatible gateway: sign up and create a key at app.mor.org. In Agent Zero’s model settings, choose Other OpenAI compatible, set the API base to https://api.mor.org/api/v1, paste the key, and enter a model name from the gateway’s list. It serves a selected part of the marketplace, so check that list for current names.

Option B: your own Uplink gateway

Morpheus Uplink is a small gateway you run yourself, paid from your own MOR. It gives your agents a web address and a key each, and speaks the same language as OpenAI’s API, so Agent Zero treats it like any other provider.

On 28 September 2026 we pointed our local Agent Zero at our Uplink and gave it two tool-using tasks: hash a string with the code tool, then write, run and report a small Python script. Both answers were correct and each task finished in under 40 seconds. Uplink’s usage log attributed every request to the key we had issued for Agent Zero.

We gave Uplink its own agent profile, so the scheduled jobs on our other profiles stayed on Venice. A profile is two small files in your data folder.

title: Morpheus Uplink
description: Chat and utility models served through my Uplink gateway.
context: ''

{
  "allow_chat_override": false,
  "chat_model": {
    "provider": "other",
    "name": "0x<model-id-from-uplink>",
    "api_base": "https://your-uplink-host/v1",
    "api_key": "sk-your-uplink-key",
    "ctx_length": 128000,
    "vision": false,
    "kwargs": { "max_tokens": 8192 }
  },
  "utility_model": {
    "provider": "other",
    "name": "0x<model-id-from-uplink>",
    "api_base": "https://your-uplink-host/v1",
    "api_key": "sk-your-uplink-key",
    "ctx_length": 100000
  },
  "embedding_model": {
    "provider": "huggingface",
    "name": "sentence-transformers/all-MiniLM-L6-v2"
  }
}

Three details matter:

• Use the model’s ID code, not its name. The ID is a long string starting with 0x. Several marketplace models share a name, and Uplink resolves a shared name to the last catalogue entry, which can be a far pricier bid. GET /v1/models lists each model’s ID under morpheus.blockchainId.
• Put the key on the profile. Without an api_key in the profile, Agent Zero falls back to the API_KEY_OTHER environment variable and sends whatever it holds to your Uplink host. In our setup that variable held a different provider’s key.
• Give each agent its own Uplink key. The usage log then splits requests and tokens per agent, and you can revoke one key without touching the rest. Every key is spend authority over your wallet’s MOR, so keep it out of chat logs and screenshots.

Replies take a little longer than on Venice or a local model. In return, your agent runs on decentralised infrastructure and adds to measured demand on the network. That demand doesn’t feed MOR tokenTokenA digital unit of value or access rights tracked on a blockchain. Tokens can represent ownership in a project, a right to use a service, a share of future revenue, or simply a tradable asset with no underlying claim.Like a physical poker chip a casino issues. The chip itself has no value. What makes it worth something is what it lets you do at the casino, what the casino has promised, and how much other people will pay you for it.Token in the glossary → value directly: the protocol’s revenue is yield on capital deposits, not inference fees.

Step 5: Keep it updated

Your settings live in the mounted folder, so updating means replacing the container, not reinstalling:

docker pull agent0ai/agent-zero
docker stop agent-zero && docker rm agent-zero
# then re-run the docker run command from Step 1

Copy the data folder somewhere safe first. An update can change the settings format, and a backup of ~/agent-zero-data is the difference between a rollback and an afternoon of reconfiguring.

The three inference routes compared

I use all three, often at once. The utility model runs locally because it fires constantly and handles the agent’s own housekeeping. The chat model runs on Venice because it needs more than my hardware serves quickly. A separate profile runs through our own Morpheus gateway when I want the whole path on decentralised infrastructure.

What the agent can do

With the stack running, your Agent Zero instance can:

• Research topics and synthesise information from the web
• Execute code (Python, shell) to process data
• Read and write files in its workspace and any folder you mount into it
• Call external APIs on your behalf
• Run scheduled tasks without you in the chat

That last pair is the risk as well as the point. Every key in its settings is authority the agent can use without asking, so keep wallet private keys out of it and give each integration its own revocable key.

Troubleshooting

Agent not responding. Check the container logs: docker logs agent-zero -f. A wrong API key or an unreachable API base is the usual cause.

Local model unreachable. Inside Docker, localhost means the container itself. Use host.docker.internal for anything running on the host.

Memory errors or poor recall. The embedding slot must hold an embedding model, not a chat model. The default Hugging Face model works without a key.

Port already in use. Map a different host port, such as -p 5080:80, and open http://localhost:5080.

Slow responses. Morpheus sessions carry more latency than a direct API. For a local model, check that it fits in available memory.