Documentation

First 5 minutes

1. Create an account. Username and password. There is no email field, which also means there is no password reset — store the password somewhere safe.
2. Start a chat and ask something. You are on a free model to begin with, so it costs nothing.
3. Create a container under Container → Neu. Pick Ubuntu 24.04 if unsure.
4. Attach it to the chat from the chat header. Now the AI works inside that machine.
5. Ask it to build something. The first command it wants to run will stop and wait for your approval.

Top up credit only when you want paid models. Free models work at zero balance.

How it fits together

Four things, and it helps to keep them apart:

• Chat — the conversation. Belongs to you, has one model at a time (changeable).
• Container — a real Linux machine. Independent of any chat; you can attach the same container to several chats, and its files persist.
• Plan — what hardware you may use: cores, memory, how many containers run at once, how long an agent may run, how many public ports.
• Credit — prepaid money for model usage. Separate from the plan. Paid per request.

The important consequence: a plan does not include model usage, and credit does not buy hardware. They are two meters because they are two different costs.

Chat basics

Type, send, read. The reply streams token by token and the cost strip under it fills in while it writes.

• Edit a message to fork the conversation from that point — the original stays.
• Stop halts generation; you are billed only for what was produced.
• Rename a chat, or let the first exchange title it automatically.
• Export a chat to Markdown or JSON from the chat menu.
• Pause a chat to stop any agent activity in it without deleting anything.

Choosing a model

The picker above the input lists every available model with its price per million tokens and its context length. Switch mid-conversation and the thread comes with you.

• Free models cost nothing and work at a zero balance. Good for drafts and routine work.
• Reasoning models think before answering. They cost more and are worth it on hard problems, not on simple ones.
• Long-context models matter when you paste a big file or work a long thread.
• A practical pattern: cheap model to explore, strong model for the hard step, cheap again to tidy up.

Prices are the provider's own. There is no markup on tokens.

Files and images in chat

Attach with the clip, or paste an image straight into the box. Text files are read; images go to vision-capable models.

• Attachments are stored with the chat, so the model can refer back to them later.
• Large files are better placed in the container and read from there — cheaper, because the model reads only the part it needs instead of the whole file every turn.

Long conversations

When a thread approaches the model's context limit, older turns are compacted into a summary so the conversation can continue instead of failing.

• Compaction is shown in the thread — you can see where it happened.
• It uses a cheap model on purpose, so a long conversation does not get expensive just by existing.
• Anything in the container is unaffected; files are not part of the context.

Prompt optimiser

A separate area for building and refining prompts. Write a rough instruction, have it rewritten and sharpened, and keep the good ones.

• Saved prompts can be reused in any chat.
• Useful for anything you run repeatedly — a review checklist, a commit-message format, a scheduled task's instruction.

Skills

Reusable instruction files the AI can load when relevant, instead of you re-explaining a workflow every time.

• Attach skills to a chat, or set defaults that apply to every new chat.
• A skill is a plain file; you can edit it and it takes effect on the next turn.

Memory and writing style

Facts worth carrying between conversations — how you like code formatted, what stack you use, what you are working on — plus an optional writing-style profile so replies sound the way you want.

• Memory is yours alone and is never shared between accounts.
• You can read, edit and delete every entry. Nothing is stored that you cannot see.

Context stitching

Pull relevant material from your own documents and past work into a conversation, so the model answers with your context rather than in general.

• Strictly per account. There is deliberately no operator read path into it.

Research mode

For questions that need sources rather than an opinion. It gathers material, keeps track of where each claim came from, and shows the sources alongside the answer.

• Claims are linked to sources so you can check them rather than trust them.
• Slower and more expensive than a normal answer — use it when the citation matters.

Voice

Speak instead of typing, and have replies read aloud. Recognition and speech run in your browser: no audio is sent to this server, there is no third-party voice key, and nothing is billed for it.

Availability depends on your browser. Chrome and Edge are the most reliable.

Buddy

An optional on-screen companion that reflects what the system is doing — working, waiting for approval, out of credit. You can name it and give it a personality, or switch it off entirely.

It is display only: it has no ability to act, and its state is recomputed from your account on every request rather than trusted from the browser.

Import from ChatGPT, Claude, Gemini

Bring your existing conversations in. Export from the other service, upload the file here, preview what was found, then confirm.

• Parsing happens locally and is free — you are not billed to import.
• Imported chats are read-only history until you continue one; only continuing costs credit.
• Large exports are streamed rather than parsed in memory, so a big archive will not fail.

Containers

Container → Neu, pick a base image (Ubuntu 24.04, Debian 12, Alpine) and a name. Ready in seconds.

• You are root. apt install, compile, run a database, start a service.
• Files persist across restarts and across chats. The container is the durable thing; a chat is not.
• Attach to a chat so the AI works there. Attach the same container to several chats and they share one filesystem.
• Pause when idle: the disk is kept and the slot is freed.
• Snapshots let you save a known-good state before a risky change.

Containers run under a sandbox (gVisor) with a restricted syscall profile — that is what makes it safe to let an AI have root in one.

Command approval

Every command the AI wants to run appears in full and waits.

• Erlauben runs it. Bearbeiten lets you change it first. Ablehnen refuses and tells the model why, so it can try something else.
• Deny is placed away from Allow so a destructive command is never one mis-tap away.
• Allow-list commands you are tired of approving (ls, cat, git status) and only the interesting ones will stop.
• Every executed command is logged with its exit code and output.

Files

A real file tree of the container. Browse, open in the editor, upload, download.

• Download a single file or a whole folder as an archive.
• Edits you make are immediately what the AI sees — same filesystem, no sync step.

Terminal

A shell in the same container, available mid-task without stopping the agent.

• Fix one thing by hand and hand it back; the conversation keeps its context.
• Full terminal, so htop, vim and tmux behave normally.

Network drive (SMB)

Mount a container's files as a network drive on your own computer, so you can work in your normal editor against the same filesystem the AI uses.

• One share belongs to exactly one workspace of exactly one account.
• Credentials are generated for you; do not reuse them elsewhere.

Public ports

Start something listening in the container, then publish that port. You get an HTTPS URL on *.zerolog.ch immediately, certificate included.

• The hostname contains your account name, so nobody can squat yours.
• How many ports you may publish is set by your plan.
• Anything published is public. Put authentication in front of anything that should not be.

Custom domains

On Pro and above, point your own domain at a published port. Add the domain, set the CNAME it shows you, and it verifies and issues a certificate.

• Max allows several domains; Pro allows one.
• Remove a domain and the certificate and routing are cleaned up.

Outbound network

Containers reach the internet through a controlled gateway rather than directly.

• Package registries, source hosts and provider APIs are reachable by default.
• Connection rate and concurrency are capped per container — generous enough for a build, low enough that the platform cannot be used to flood anyone.
• If something you need is blocked, ask: it is an allow-list, not a wall.

Virtual machines

Where a container is not enough — a different kernel, systemd, or Windows — a full VM can be created from an admin-defined template, within your quota.

• You choose from templates rather than free-form arguments.
• You see and manage only VMs you created.

Desktop control

For graphical work, a desktop session the AI can see and control, in its own section.

• Requires an active private-network session; it is not exposed publicly.
• Scoped to your account like everything else.

/goal

Type /goal and what you want, in plain language:

/goal migrate this project to TypeScript and get the tests green

The agent plans, works, verifies its own result, and keeps going until it is done or genuinely stuck.

• It keeps running when you close the tab. Come back to the log.
• Every step is recorded: reasoning, commands, output, cost.
• Take over in the terminal at any moment; the run continues around you.
• Run length follows your plan — up to 12 hours on Pro, unlimited on Max.
• Set a spend cap for the run if you want a hard ceiling.

Give it a goal with a checkable end state ("tests pass", "the page builds"). A vague goal produces vague work.

Jobs and logs

Every long-running piece of work — an agent run, an import, a snapshot — appears under Jobs with its state and its log.

• Follow a running job live, or read it afterwards.
• Cost is attributed per job, so you can see what a particular run actually cost.

Scheduled tasks

Give an agent a job and a time: a nightly build, a daily check, a weekly summary.

• Schedules follow your timezone, not the server's.
• Each run is capped so a loop cannot quietly drain credit.
• Every run leaves a log you can read in the morning.

Invisible automation

Standing permissions for routine actions, with an approval queue for anything outside them, plus a digest of what was done.

• Grants are explicit and revocable — nothing gains permission silently.
• The digest exists so "it ran while I was away" never means "I do not know what happened".

Cost per answer

Under each reply: input tokens, cached tokens, output tokens, and the price — updating while it streams.

• Verbrauch holds the full ledger per chat, per model and per day.
• Cached input is cheaper than fresh input; long threads benefit from it automatically.

Credit and top-ups

Credit is prepaid. Top up in CHF by card or TWINT. Nothing is ever charged automatically and there is no subscription to model usage.

• Tokens are billed at the provider's own price with no markup.
• Topping up adds a 10% service fee and a 3% currency buffer, shown in the quote before you pay.
• Credit is not redeemable for cash.

Spend limits

Set a hard limit per account, per chat or per agent run.

• At the limit, work stops. It does not continue and bill you later.
• Free models keep working at a zero balance, so an empty account is not a locked account.

Budget governor

Watches spending as it happens and can downgrade to a cheaper model when a run is burning faster than expected, rather than stopping outright.

• Every downgrade is logged with the reason, so a surprising answer has an explanation.

Plans

A plan buys hardware, not tokens.

Upgrading takes effect immediately; downgrading at the end of the period.

Secrets vault

Store credentials the AI needs — a deploy token, a database password — encrypted, and attach them to a chat when needed.

• Values are encrypted at rest and never returned to the browser after saving.
• A chat that has used vault credentials is marked, and from that point it is restricted to zero-retention providers.

Your own API key

Already paying a provider? Add your key and that usage goes to your account there instead of your ZeroLog credit.

• Keys are encrypted at rest and never shown to the browser again.
• Cost is still displayed per answer, so you keep the same visibility.

Your own Claude / ChatGPT / Gemini account

Connect an existing subscription and run the vendor CLIs on it, rather than paying per token.

• Login mirrors each CLI's own flow: start, open the URL, paste the code back.
• Usage is billed by that vendor to your subscription, not here.

Anonymous chats

Switch a chat to anonym and it is encrypted in your browser before it is sent. The server holds ciphertext plus the billing counters.

• Nobody operating the service can read the stored content.
• Lose the passphrase and it is gone permanently. No support request can recover it.
• The prompt still reaches the model provider to be answered. Encryption protects storage here, not the fact that a model must read your question.
• You can make it the default for every new chat.

Zero data retention

Requests can be restricted to providers that do not retain prompts. This happens automatically once a chat touches vault credentials, and can be set deliberately.

• If no zero-retention provider is available for the chosen model, the request fails rather than falling back to one that retains.

Image generation

Ask for an image in a normal message. The AI picks a suitable model, or you name one.

• Fast and cheap for drafts and backgrounds; the strong one for detail and composition; a text-capable one when the picture must contain readable words.
• Editing: upload an image and ask for a change, and it edits your picture rather than inventing a new one.
• Each image shows its price like any other request.

Gallery and backgrounds

Generated and uploaded images collect in the gallery. Any of them can become your interface background, or be downloaded.

Connectors

Optional links to outside services — for example an image service or a Google account — enabled per account.

• Connecting is your action; every call is logged; disconnecting purges what was stored.

Push notifications

Get told when a long run finishes or an approval is waiting, instead of watching a tab.

• Browser push; allow notifications once and it works on desktop and Android.

Webhooks

Let an outside system trigger work here, or be told when something finished.

• Incoming requests are verified; unsigned calls are refused.

Sharing a container

Invite someone to a container as owner, read-write or read-only.

• Read-only really is read-only, including through links and the terminal.
• The owner can list and revoke every grant, including ones made by others.
• Their actions under your resources remain your responsibility toward the operator.

Android app

Install the app, open Geräte on the website and tap Gerät koppeln. Scan the code and you are signed in.

• Your password is never typed on the phone — the code is exchanged for a device token.
• Lost the phone? Revoke that single device; every other session stays signed in.
• The app is a real app, not a wrapped website: the interface ships inside it, only data travels.

Claude Code and other CLIs

Vendor command-line tools can run against a container here, so agent work happens on this machine rather than your laptop.

• Either on your own connected subscription, or on models billed from your credit.
• Output is rendered the way the CLI intends, so the view matches what you would see locally.