Install it once. Use it from every browser.

Put Dogubako on a home server, a NAS or a VPS. The people you share it with sign in from a laptop or a phone, over your LAN or Tailscale, and every job runs on that one machine, with the engines already installed.

Set it up Self-hosting docs

Docker Compose on Linux. Or have your agent set it up

An animation of a first install: docker compose up builds and starts the server, tailscale serve puts it on a private tailnet with HTTPS, the server log shows a one-time setup token, and a phone opens the address, enters the token and creates the owner account.

    For the machine that’s always on.

    A home server in a cupboard, a NAS, a small VPS or the spare desktop at the office. One install serves the whole household or team. Laptops, phones and tablets use it from a browser, and agents and scripts use it with their own tokens. Video, OCR and speech run on the server, so nobody installs FFmpeg on their phone.

    Every job runs on the server. Results come back to whoever asked, and only they can open them.

    What the server adds.

    The same tools as the desktop app, plus what a machine shared by several people needs.

    Audit logAdmin → Audit log
    1. alexloginok
    2. alexuser.createmedia-bot (agent)ok
    3. alextoken.createfor media-botok
    4. media-bottool.runspeech.transcribesucceededmcp
    5. media-bottool.deniedpdf.mergedeniedmcp
    6. samtool.runnetwork.http_headersfailedweb: 'router.lan' resolves only to non-public addresses; blocked by network policy
    7. junlogindenied
    Engines, installed once
    The image builds with FFmpeg, ImageMagick, Ghostscript, Poppler, qpdf, Tesseract, ExifTool, Pandoc, 7-Zip, whisper.cpp and Piper, at pinned versions. LibreOffice is one line in .env away. Nobody installs anything on their own device.
    Accounts and roles
    Owner, admin, user and agent. Signing in is always required, also on a LAN or a tailnet. Passwords are hashed with Argon2id, and sessions live in HttpOnly, SameSite=Strict cookies.
    Quotas and limits
    Every account has a storage quota (10 GB by default) and a limit on jobs at once (2 by default). Uploads and results are deleted after 24 hours unless you change it, and every job has a time limit.
    Files only their owner can open
    Files are addressed by random ids, never by paths on the server, and every lookup checks who owns them. Ask for someone else’s file and you get a 404.
    URL tools stay off your network
    DNS, HTTP and TLS tools refuse loopback, private and link-local addresses, Tailscale’s 100.64.0.0/10 included, so the server can’t be used to probe your home network. Redirects are checked too.
    An audit log
    Sign-ins, setup, token and policy changes, uploads, every tool run and every refused call, with who did it and how it arrived.
    A locked-down container
    Read-only root filesystem, all Linux capabilities dropped, no-new-privileges, and CPU, memory and process limits. External programs get exact arguments, never a shell, with timeouts and memory caps.
    Bubblewrap, on native installs
    Running without Docker on Linux, set DOGUBAKO_SANDBOX=bwrap and each external program runs with no network, a private /tmp and only its own job’s files in view.
    A key for each agent
    Agent accounts start with no tools at all. Allow video.* for one and image.* for another, give each a token, and connect them over MCP or the HTTP API. Agents and automation
    Plain words, with a shared model
    People can type what they want done instead of picking a tool. It’s off until each person turns it on in Settings → Plain words. Set DOGUBAKO_ASSISTANT_BASE_URL, _MODEL and _API_KEY in .env to offer one model to everyone, or run one beside it with docker compose --profile local-model up -d. The key stays on the server, and runs still go through the same permissions, quotas and audit log. The request, file names and tool results go to that model; the files themselves don’t. How plain words works

    Set it up

    You need a Linux machine with Docker and Docker Compose, a few gigabytes of disk for the image and your files, and spare CPU if you’ll transcode video or transcribe speech.

    1. Get the code and start it

      The server runs as user 10001 inside the container, so give it the data folder first. The first build compiles Dogubako and installs every engine at a pinned version, so it takes a while. The image is about 1.5 GB, plus about 500 MB with LibreOffice. A prebuilt image for linux/amd64 is planned for the alpha release; until it’s published, compose builds it from source.

      $ git clone https://github.com/Mischa-dev/Dogubako
$ cd Dogubako
# optional: LibreOffice, a shared model
$ cp .env.example .env
$ mkdir -p data && sudo chown 10001 data
$ docker compose up -d --build

    2. Keep it private, reach it anyway

      The compose file only listens on 127.0.0.1, so nothing outside the machine can reach it yet. Tailscale is the easy way in: your own devices get HTTPS and no port is opened to the internet. Then set DOGUBAKO_PUBLIC_URL to that address and DOGUBAKO_SECURE_COOKIES to "true"; both lines are in docker-compose.yml, commented out.

      For a LAN, change the port mapping to "8420:8420", ideally behind a reverse proxy with HTTPS. Don’t publish port 8420 to the open internet.

      # Tailscale on the host
$ tailscale serve --bg 8420

# or as a sidecar container
$ TS_AUTHKEY=tskey-auth-… docker compose \
    -f docker-compose.yml -f deploy/docker-compose.tailscale.yml up -d

    3. Create the owner account

      On first start the server prints a one-time setup token; a restart before the owner exists prints a new one. Open the server’s address, enter the newest token, and choose the owner’s username and a password of at least 10 characters.

      $ docker compose logs dogubako | grep "Setup token" | tail -n 1

    4. Add people and agents

      In Admin → Users & agents, or from the host. People get every tool by default; agents get only what you list. A token is shown once, so store it right away.

      $ docker compose exec dogubako dogubako users create sam --role user
$ docker compose exec dogubako dogubako users create media-bot \
    --role agent --allow 'video.*' --allow 'speech.*'
$ docker compose exec dogubako dogubako tokens create \
    --user media-bot --name laptop-agent
dgb_…

    Or have your agent set it up.

    If a coding agent such as Claude Code runs on that machine, give it this prompt. It points to a page written for agents: every step above, how to connect itself over MCP, and what it has to ask you first.

    Read agent-install.md

    Prompt

    Install Dogubako on this server and connect it to me over MCP. Follow the instructions at https://dogubako.app/agent-install.md and ask me before any step that opens ports or changes the firewall.

    The how-to lives in the docs

    HomeWhat Dogubako is, and the app in motion DownloadAlpha status, the Mac app, building from source