now brewing · open to small teams

Your daily
mug of AI.

DayMug brings AI into a place your whole team can share — your laptop, your phone, your tablet. Together. In sync. Yours to keep. Pour one and pass it around.

Set up
in 5 minutes
Works on
any browser
For
the whole team
Updates
one click
01 live agent
02 served live
your daily mug
§ 01 — what's inside

A shared room for your AI, not a single seat.

AI is amazing when you're alone with it. DayMug makes it amazing when you're not. Bring everyone into the same conversations, pick up where someone else left off, keep your work close at hand.

01 / 04 // for the team

Skills brewed once, shared by all.

Give every person their own AI — with its own name, its own job, its own rules about what it can touch. Set up a skill once and the whole team can reach for it — no copy-pasting prompts between teammates.

ready-made roles shared skills simple permissions
02 / 04 // live

Watch it, pause it, pass it along.

See the answer arrive as it's being thought of. Two people can watch the same conversation at once. Stop it mid-sentence, change your mind, hand it off to a colleague and pick up later from another device.

live answers watch together stop any time
03 / 04 // yours to keep

Your work stays with you.

Conversations, files, history — they all live on a computer you choose. No tracking, no middleman, no surprise bills. Updates land with one click, and you can go back if something feels off.

no tracking your data undo updates
04 / 04 // anywhere

It's just a website.

Open it in any browser — laptop, phone, tablet, the cafe screen. Nothing to download. The conversation you started on the couch is still right there when you sit down at your desk.

any browser mobile-ready no app needed
§ 02 — what it looks like

A workspace,
not a conversation window.

Your conversation on one side, the files being worked on right beside it. Switch between your agents with a click. See what's happening in real time — no need to ask "did you change that yet?"

  • Switch between teammates instantly — each keeps their own conversations and history
  • Watch the answer come together as it's being thought of
  • Browse and preview files in the same window, no jumping around
  • Hand off mid-conversation — they pick up where you stopped
§ 03 — install

Pour it once. Drink for years.

Setting up takes about five minutes. After that, everyone on your team just opens a page in their browser — there's nothing else to install on the side.

one line  — for the person setting it up
# pop this into the computer you'd like daymug to live on,
# then everyone on the team can open it in their browser

$ curl -fsSL https://daymug.com/install.sh | bash
What you need — a short checklist
  • A computer any Mac or Linux that stays on
  • A browser whichever one the team already uses
  • An AI plan your existing subscription works
  • Set-up time about five minutes
  • Updates one click, easy to undo
  • Your data stays on the computer you choose
after the installer finishes

Pick how the team reaches it.

DayMug listens on plain HTTP at 127.0.0.1. To let anyone outside this machine connect, pick one of the three paths below. The installer prints the same menu, so you can also decide later — nothing here is locked in.

Path B · advanced
Your domain + nginx + TLS cert
Terminate TLS yourself with nginx in front of DayMug. Works with any cert authority.

Use this when you already own a domain, you have a public IP (or your own reverse proxy), or your organisation requires a specific cert chain.

  1. Point an A / AAAA record at this machine.
  2. Issue a cert with Let's Encrypt:
    sudo apt install -y certbot \
      python3-certbot-nginx
    sudo certbot --nginx \
      -d chat.example.com
    Certbot installs a renewal timer automatically.
  3. Drop an nginx server block in /etc/nginx/conf.d/daymug.conf. WebSockets need the Upgrade headers and a long proxy_read_timeout:
    server {
      listen 443 ssl http2;
      server_name chat.example.com;
      ssl_certificate     /etc/letsencrypt/live/…/fullchain.pem;
      ssl_certificate_key /etc/letsencrypt/live/…/privkey.pem;
      location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_http_version 1.1;
        proxy_set_header Host              $host;
        proxy_set_header Upgrade           $http_upgrade;
        proxy_set_header Connection        "upgrade";
        proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_read_timeout 3600s;
      }
    }
  4. sudo nginx -t && sudo systemctl reload nginx — done.
In this mode you don't need cloudflared or daymug website request. The installer prints the same nginx snippet so you can paste it from the terminal.
Path C · quickest
Localhost / LAN only
Skip the public-facing layer. DayMug is reachable on this machine and (optionally) on the same network.

Use this when you're evaluating it, you're the only user, or you're inside an office that already has its own VPN.

  1. Open the browser on this machine:
    http://127.0.0.1:8080
  2. To share with the LAN, change server.addr in ~/.daymug/config.yaml from :8080 to 0.0.0.0:8080, then restart:
    systemctl --user restart \
      daymug.service
No certs, no tunnels, no proxy. Anything outside your LAN still can't see it — that's the whole point.
§ 04 — config

Every knob, named plainly.

DayMug reads one YAML file at startup. Copy docs/config.sample.yaml, change the fields below, and restart the service when you are done.

load order

DayMug tries --config <path>, then DAYMUG_CONFIG, then config.yaml next to the binary.

reload

The file is read once. Restart with systemctl --user restart daymug.service after a change.

minimum

A usable file needs server.addr, admin.bootstrap_usernames, and at least one providers entry named default.

server

Network address and install identity for this DayMug instance.

server.addr
:8080

HTTP listen address. Use 127.0.0.1:8090 behind a local reverse proxy, or 0.0.0.0:8080 / :8080 when exposing directly.

server.public_url
empty

External base URL users open. Notifications use it to build clickable deep links; without it, pushes can still send text but cannot open the conversation.

server.client_id
empty

Stable install UUID reported by heartbeats. The installer writes it; leaving it empty works, but each startup uses a temporary identity.

auth

Browser session lifetime and login method switches.

auth.session_ttl
720h

Login session lifetime in Go duration syntax. The session cookie max-age follows this value.

auth.cookie_secure
false

Adds the Secure flag to the session cookie. Set true for HTTPS deployments.

auth.password_login_enabled
true

Enables username and password login. Turn it off when OIDC is the only allowed sign-in path.

admin

Recovery path for administrator access.

admin.bootstrap_usernames
[]

Usernames listed here are promoted to admin on every startup. Add yourself and restart if all admins were accidentally removed.

users

Default filesystem root for user working directories.

users.default_home_root
~/.daymug/users

New users get <root>/<username> as their default work directory. ~/ expands to the service user's home and must resolve to an absolute path.

providers[]

Credential pools for Claude, Codex, or MiMo. The first entry is the new-conversation default, and one entry must be named default.

providers[].name
required

Unique account name inside the YAML. DayMug requires at least one provider named default.

providers[].type
required

Backend type: claude, codex, or mimo. It decides which CLI adapter runs the conversation.

providers[].max_concurrent
1 if <=0

Maximum simultaneous conversations for this account. Extra work queues and clients see a one-based queue position.

providers[].config_dir
type-dependent

Credential directory. Claude and MiMo map it to CLAUDE_CONFIG_DIR and can fall back to ~/.claude; Codex maps it to CODEX_HOME and must be explicit.

providers[].env
{}

Extra environment variables passed only to the child CLI. Use field names such as OPENAI_API_KEY or ANTHROPIC_AUTH_TOKEN; keep real secrets out of public docs.

providers[].models
[]

Optional chat model IDs advertised for this provider type. The first non-empty list wins, and its first model becomes the default for new conversations.

providers[].summary_model
empty

Optional model for internal summaries: automatic titles and /compact.

providers[].runner_mode
inherits global

Per-account override for process spawning: cli pipes stdio, pty wraps the CLI in a pseudo-terminal.

runner

Global CLI launch mode and silence watchdogs.

runner_mode
cli

Global process mode. cli uses stdin/stdout/stderr pipes; pty gives CLIs a terminal-like process, useful for login commands that check isatty().

runner_stall_timeout
10m

How long stdout may be silent before DayMug probes process CPU time and session logs instead of immediately killing the CLI.

runner_max_silent_timeout
2h

Absolute limit for one stdout-silent stretch, even if the activity probe still sees work happening.

tools

Tool names the admin UI can grant to users for Claude runs.

tools.available[].name
none

Tool shown in the admin UI and passed to Claude --allowedTools when selected.

tools.available[].patterns
[]

Optional fine-grained allow patterns for a tool, such as limiting Bash to specific command prefixes.

tools.default_for_new_user
[]

Tool names preselected when an administrator creates a new user. An empty allowed-tools value on a user means no DayMug-side restriction.

sandbox

Optional per-agent process isolation.

sandbox.enabled
false

Turns isolation on when paired with a real sandbox type. enabled: true with type: noop is normalized back to no isolation.

sandbox.type
noop

noop inherits the service user's filesystem access. bwrap uses Linux bubblewrap and confines normal users to their work directory.

sandbox.network
true

Only meaningful for bwrap. True keeps host network access; false starts the jailed process offline.

sandbox.extra_ro_binds
[]

Extra absolute host paths mounted read-only into every jailed agent, useful for shared reference assets.

sandbox.extra_rw_binds
[]

Extra absolute host paths mounted read-write into every jailed agent. Keep this narrow because it expands what agents can modify.

oidc

Optional Casdoor or generic OpenID Connect single sign-on.

oidc.enabled
false

Enables OIDC login. When false, every other OIDC field is ignored.

oidc.issuer
required if enabled

Identity-provider issuer URL. DayMug discovers /.well-known/openid-configuration from it.

oidc.client_id
required if enabled

OAuth client ID issued by the IdP for this DayMug app.

oidc.client_secret
required if enabled

OAuth client secret. Store the real value only in private config, never in public examples or screenshots.

oidc.redirect_uri
required if enabled

Callback URL registered with the IdP. It must exactly match the public app URL plus /api/auth/oidc/callback.

oidc.scopes
openid, profile, email

OAuth scopes requested. Keep profile when using Casdoor so groups, roles, and permissions are available.

oidc.group_claim
groups

Claim name DayMug reads for group membership.

oidc.role_claim
roles

Claim name DayMug reads for role membership.

oidc.permission_claim
permissions

Claim name DayMug reads for permission membership.

oidc.required_groups
[]

Allowed group values. If any required list is non-empty, a user needs at least one match in one configured dimension.

oidc.required_roles
[]

Allowed role values. Empty means this dimension does not restrict access.

oidc.required_permissions
[]

Allowed permission values. With all required lists empty, any authenticated IdP user may enter subject to provisioning.

oidc.auto_provision
true

Creates a local non-admin user on first successful OIDC login when no local user matches the email. False makes OIDC a closed allowlist.

oidc.button_label
Sign in with SSO

Text shown on the login page SSO button.

upgrade

Service restart and health-check settings for self-upgrade.

upgrade.service
daymug

systemd unit name the watchdog restarts after swapping the binary.

upgrade.service_mode
user

user runs systemctl --user; system runs system-level systemctl.

upgrade.health_path
/api/health

HTTP path polled after an upgrade. Host and port are derived from the configured listen address.

upgrade.health_timeout
60s

Maximum time to wait for a healthy response before rolling back to the previous binary.

usage

Timezone used to group token and cost usage by day.

usage.timezone
Asia/Shanghai

IANA timezone name, UTC, or Local. It controls the day boundary for usage charts; changing it does not rewrite older rows.

Not YAML fields: SQLite always lives at <binary_dir>/data/database.db; the self-upgrade manifest URL is hard-coded in the server; per-user provider bindings live in the database and are managed from the admin UI.
§ 05 — usage

Three sips and you're brewing.

From signing up to your first conversation in about a minute. Nothing to read, nothing to memorise — you'll figure it out as you go.

step / i.

Pick an agent

Choose an agent for the job. Define its role, and decide exactly what it's allowed to touch.

— an agent name: "Writer" role: edit drafts perms: read/write
step / ii.

Pick a working folder

Point each conversation at a folder. Pick a different one next time — every conversation stays in its own lane, with no spill-over between projects.

— this conversation folder: ~/welcome-emails — next conversation folder: ~/release-notes
step / iii.

Start the conversation

Type what you want and watch the answer come together. Hand it off to a teammate, or pick it up later from another device — the conversation is waiting where you left it.

you soften welcome email writer reading welcome.md writer saved — try it?
§ 06 — questions

Frequently brewed.

Short answers to the things people usually wonder about. If yours isn't here, drop us a line.

Q.01 Why use this instead of just talking to AI on my own?

AI on its own forgets. DayMug remembers — your conversations, your files, what your team has been working on. It's the difference between asking a stranger and asking a colleague who knows the room.

And because it's a website, you don't need to learn anything new. Open the link, talk to your agent, hand the conversation to a teammate when you're done.

Q.02 Where does my data live?

On a computer you choose. DayMug doesn't send anything back to us — no tracking, no analytics, no surprise bills. The only thing that talks to the outside world is the AI itself, the same way it would on your laptop today.

Q.03 Do I need to pay for the AI separately?

Yes — DayMug works with whatever AI plan you're already on. We don't sell credits or stand between you and your agent. Bring your favourite, hook it up once, and DayMug just adds the friendly room around it.

Q.04 Can a team share one AI account?

Yes. If one teammate is using it, the next one waits in a polite line — and they can see how soon they're up. Or give each person their own account if you want stricter separation. Whatever fits.

Q.05 Does it really work on my phone?

Yes — open it in your phone's browser and you'll get a layout made for the smaller screen. Catch up from the train, the couch, the queue at a cafe. The conversation is the same one you started on your laptop, just sized for your hand.

— still curious? drop a line to [email protected]

Ready to pour one?

Five minutes to set up. Zero minutes to learn. The AI you already know, fresh and friendly — for the whole team.