Dulus Terminal Agent Setup Guide

TL;DR

TL;DR: Dulus is a Python autonomous agent CLI that can run with browser-captured web AI sessions, LiteLLM providers, Ollama/local models, MCP tools, WebBridge browser automation, voice features, and Docker deployment; test it in a disposable workspace before giving it real files.

Source and Accuracy Notes

This article uses official project material from KevRojo/Dulus, mainly the README sections on quick start, installer profiles, Docker, models, tools, MCP, voice, memory, sandboxing, and project layout. Commands are preserved from project docs. Because Dulus has many optional features, this guide separates minimum install, richer profiles, Docker, models, and security review instead of treating it like a single-purpose package.

Dulus uses the author’s phrase “IA” throughout its docs. This article uses “AI” for consistency, but keeps command names and package names exactly.

What Is Dulus?

Dulus is a Python autonomous agent designed to make frontier models available through several routes: browser session capture for services such as Gemini guest mode, Claude.ai, Kimi, Qwen, and DeepSeek; paid providers through LiteLLM; local models through Ollama; and custom endpoints. It wraps those models in an agent loop with shell/file tools, prompt mode, memory, MCP integration, web/browser automation, OCR, voice input/output, and an embedded sandbox concept.

The project’s pitch is access flexibility. Instead of assuming one API key and one model provider, Dulus tries to meet users where they already have access: web sessions, local models, provider APIs, or no-key guest experiences. That makes it interesting, but also increases operational risk. A tool that can read files, patch code, run commands, browse, and interact with web sessions needs careful permission boundaries.

Repo-specific signals matter here. Dulus is not a tiny wrapper around a chat API. It documents installer profiles, optional extras, Docker Compose, WebBridge via Playwright, MemPalace semantic memory, slash commands such as /sticky_input, MCP configuration through .mcp.json, and examples for piping Git diffs into the agent. Treat it as an agent workbench.

Repo-Specific Setup Workflow

Step 1: Start with package install or installer

The simplest documented command is:

pip install dulus

The README also presents direct use after install:

dulus

For a guided native install on macOS/Linux/WSL, project docs provide:

curl -fsSL https://raw.githubusercontent.com/KevRojo/Dulus/main/install.sh | bash

Windows PowerShell installer:

irm https://raw.githubusercontent.com/KevRojo/Dulus/main/install.ps1 | iex

The installer asks for profiles. basic maps to bare pip install dulus; richer profiles install optional pieces. Do not choose the broadest profile by reflex on work machines because voice, browser automation, memory, and sandbox tooling increase dependency and permission surface.

Step 2: Use documented installer options when you need control

Docs include dry-run, full profile, pipx, and prerelease flags:

curl -fsSL .../install.sh | bash -s -- --dry-run
curl -fsSL .../install.sh | bash -s -- --profile=full --pipx
curl -fsSL .../install.sh | bash -s -- --pre

Use dry-run when reviewing what changes will happen. Use pipx when you want a cleaner CLI install boundary than a shared Python environment.

Step 3: Enable memory only when needed

Core install and memory install are documented separately:

pip install dulus && dulus              # core CLI — fast, no compile, works on termux
pip install "dulus[memory]" && dulus    # +MemPalace per-turn memory (pulls chromadb)

Memory is useful for ongoing projects, but it persists context. For quick experiments or sensitive repositories, start without memory, then enable it after you understand storage paths and behavior.

Step 4: Run in Docker when you want isolation

Docker setup uses files from the repo and brings up services through Compose:

curl -fsSLO https://raw.githubusercontent.com/KevRojo/Dulus/main/docker-compose.yml
curl -fsSLO https://raw.githubusercontent.com/KevRojo/Dulus/main/.env.example

Then:

docker compose up -d

Enter the containerized CLI:

docker compose exec dulus dulus

The documented image is ghcr.io/kevrojo/dulus, and memory persists in the dulus-memory volume. Docker does not make dangerous prompts safe, but it helps keep Python dependencies and runtime state away from your host environment.

Step 5: Pick model route deliberately

Dulus can run with local models and provider/model names. The README includes Ollama examples:

ollama pull qwen2.5-coder
dulus --model ollama/qwen2.5-coder

It also documents LM Studio/custom naming patterns:

dulus --model lmstudio/<model>
dulus --model custom/<model>

For no-key or web-session workflows, the first-run experience may open a browser and capture a session. That can be convenient, but review what account/session you are exposing to an automation tool.

Step 6: Use pipe mode for narrow tasks

Dulus can accept stdin and run in prompt mode:

echo "explain this diff" | git diff | dulus -p --accept-all

Project docs also show commit-message style use:

echo "explain this" | dulus -p --accept-all
git diff | dulus -p "write a commit message"

Pipe mode is safer than giving an open-ended agent a full repo task because input is constrained. Still, --accept-all deserves caution: use it only where automatic acceptance is acceptable.

Step 7: Add optional features only after base CLI works

Editable install for contributors:

pip install -e .          # editable install
dulus

Manual no-deps install path shown by docs:

pip install --no-deps dulus
pip install anthropic openai httpx requests rich prompt_toolkit Flask bubblewrap-cli mempalace

Voice dependencies:

pip install sounddevice faster-whisper numpy

Audio repair command:

pip install sounddevice --upgrade --force-reinstall

The project explicitly notes that pip install portaudio will fail because there is no PyPI package with that name. That is useful troubleshooting context for voice setup.

Deeper Analysis

Dulus is most compelling as a “model access router plus agent shell.” It does not force one identity: API user, local model user, browser-session user, and Docker user can all get started. The cost is complexity. More access modes mean more failure modes: browser automation can break when UI changes, web-session capture can raise account-policy questions, voice depends on OS audio stacks, and memory brings persistence.

For developer workflows, Dulus looks useful for small bounded tasks: explain a diff, draft a commit message, inspect logs, search files, or test one folder. It is riskier as an always-on repo maintainer unless you can constrain file access, command approval, model route, and memory storage.

MCP support is important because it lets Dulus reach external tools through .mcp.json in a project root or ~/.dulus/mcp.json user-wide. That is powerful and dangerous in equal measure. A project-local MCP file can change what tools are available when you enter a repo.

Practical Evaluation Checklist

• Run pip install dulus in a clean virtual environment or pipx-style isolation first.
• Try pipe mode before open-ended autonomous tasks.
• Use Docker for experiments involving untrusted repos or unknown dependencies.
• Avoid --accept-all until command and file-edit behavior are clear.
• Keep browser session capture separate from sensitive personal/work accounts.
• Enable memory only after deciding what should persist under ~/.dulus/memory/ or project memory.
• Review .mcp.json before starting Dulus in any cloned project.
• Test Ollama/local models separately before blaming Dulus for model latency or quality.

Security Notes

Dulus can combine model output, shell commands, file editing, browser automation, MCP tools, memory, and captured sessions. That is a large trust boundary. Use throwaway repositories, test accounts, Docker, and explicit prompts during evaluation. If a workflow needs browser capture, avoid accounts with billing, admin panels, private email, or production access.

Project-local files can influence behavior through MCP configuration and memory paths. Do not run Dulus in untrusted repos without reading config-like files first. Treat persistent memory as sensitive because it may contain project names, prompts, code snippets, credentials accidentally pasted into conversations, or browser-derived context.

FAQ

Q: Can Dulus run without an API key? A: The project’s main pitch includes browser session capture and guest/web access paths, plus local models. Provider APIs remain available through LiteLLM when you have keys.

Q: Is Docker safer than native install? A: Docker isolates dependencies and runtime state better than native Python, but connected sessions, mounted files, and accepted commands can still cause damage.

Q: Should I install full profile immediately? A: No. Start with basic/core behavior, then add memory, browser, voice, or MCP features as needed.

Q: What is best first coding use case? A: Pipe a small diff and ask for explanation or commit-message help before giving it write access to a repo.

Related reading: GitHub Trending tools, Developer tools, opensquilla setup guide open source python ai tool, and trustclaw setup guide open source typescript ai tool.

Conclusion

Dulus is ambitious: a Python agent that tries to unify no-key browser access, local models, paid providers, MCP, memory, voice, and browser automation. That ambition makes it useful for hackers and risky for careless installs. Start narrow, isolate runtime, avoid sensitive sessions, and expand only after each capability proves itself on disposable work.