Your own LLMs and coding agents,
steered from your phone.

Carino Cerberus is one small self-hosted service: it runs local models, serves one OpenAI-compatible gateway, and runs coding agents in their own git worktrees.

Pre-release · Linux first · builds for macOS and Windows · one static Go binary · AGPL-3.0

01 · Three parts, one service

Three heads, as the name says.

Each part works on its own, and together they let an agent run on a model your own machine hosts.

1

Models

Cerberus runs local LLMs through the engines you already have: llama.cpp (llama-server), LM Studio and Ollama. It never ships an inference engine of its own.

  • Loads a model on the first request and unloads it when it goes idle.
  • Makes room in VRAM before a load, so two models never fight over the card.
  • Records time to first token, tokens per second and energy for every request.
2

Gateway

One OpenAI-compatible endpoint, /v1, for every app on the machine. Each request goes to a local model or to a cloud provider you reach with your own API key.

  • Local models by their own ID, cloud models as provider/model.
  • Keys live in a vault (the desktop keyring, or an encrypted file).
  • Prices, budgets and spend per model, session and day.
3

Agents

Coding-agent sessions run in a repo's detached git worktree behind a test gate, in a folder of yours, or in a scratch folder. Leave them running and steer them from any browser.

  • The built-in agent works with any model the gateway serves; other CLI agents are optional profiles.
  • Live terminal, approvals, diff review, then accept or discard.
  • Accept fast-forwards main. Cerberus never creates branches.
02 · Flows

Saved recipes, not a chatty swarm.

A flow is a fixed list of steps that hands work to models and agent sessions. Cerberus checks the list when you save it, then runs it in that order every time.

  • Plan, then fan out. A plan step asks a model for a JSON list of tasks. A fan_out step sends each task to the model its kind routes to, as a prompt or as an agent session, a few at a time.
  • Branch on the result. An if step tests a step's output (contains, regex, equals, a JSON path) or the final state of a session, and jumps forward.
  • You sign off. An approve step waits with Approve and Reject in the bell, and can send a push to your phone.
  • On a schedule, within limits. Run a flow by hand or on a schedule (weekdays 08:00, or a cron line). Each run has limits on steps, tokens, cost, parallel calls and time, and stops as limited when it passes one. Agent sessions it starts count too, for the calls they make through the gateway.
  • Why fixed steps. Models, agents and references are checked before a run starts. Steps only jump forward, so a run cannot go round in circles, and the run page shows each step's input, output, tokens and cost. A run that failed can continue from the step where it stopped.
Example: a website, checked before you see it
The built-in Website template, with a judge step added. Trigger: manual.
  1. planPlan the site. A big model returns a JSON list of parts, each {title, kind, task}.
  2. fan_outWrite the parts. Each part goes to the model its kind routes to, two at a time.
    • html → a local coding model
    • css → a local coding model
    • copy → a cloud model
  3. sessionAssemble. An agent session builds the site from the parts in a scratch folder.
  4. judgeCheck it. A judge model checks the session's folder against your criteria. A failed gate sends its feedback back to the same session, which tries again.↺ feedback → Assemble, while the gate has tries left
  5. ifPassed? Yes: go on. No: the run ends, and the judge's report is on the run page.
  6. approveApprove. Waits in the bell, and can push to your phone.
  7. outputTell me. An inbox entry that points to the files.

Limits per run: 50 steps · 200,000 tokens · $1.00 · 2 at once · 60 min (the defaults)

03 · Evals and gates

Finished is not the same as right.

An eval gives a task to one or more agent setups, and a judge model checks the work against criteria you write. The same judge can gate a flow.

  • Criteria as a graph. Each criterion is one sentence in a gate, and it can depend on others. When a criterion fails, the ones that depend on it are skipped, not judged.
  • A judge that only reads. A model through the gateway, with a fixed prompt at temperature 0. It reads the session's files, check output, transcript and diff, never runs anything, and answers pass or fail with its reasons. Secrets are masked first.
  • Gates send feedback back. Gates run in order. When one fails and has tries left, the judge writes the failures up as one message and it goes to the same session, which tries again in the same folder.
  • Compare setups. Run one task on several agent and model setups; in a repo they all start from the same commit. The run page ranks them by gates passed, criteria passed, tries and time, and each session records the exact setup it ran with.
  • Gate a flow. A judge step after a session step does the same inside a flow, and an if step branches on its passed. Its calls count toward the run's limits.
Example eval: a health endpoint
Task: add GET /health that returns {"ok": true}.
Gate 1 · Build up to 2 tries
Try 1
  • ✓has_server There is an HTTP server entry point.
  • ✗health_route GET /health returns 200 with {"ok": true}. Depends on has_server.
Feedback to the session: GET /health answers 404. The handler is registered as /healthz in main.go. Register it at /health.
Try 2
  • ✓has_server There is an HTTP server entry point.
  • ✓health_route GET /health returns 200 with {"ok": true}.
Gate 2 · Test 1 try
  • ✓tests_pass The project's tests run and none fail.

Result: 2 of 2 gates passed, Build on its second try.

04 · Agents start agents

Helpers, within the limits you set.

An agent can split its work into child sessions. Each child is an ordinary session: you can watch it, steer it, accept it or discard it.

  • Six tools. cerberus_spawn, cerberus_list, cerberus_read, cerberus_send, cerberus_wait and cerberus_stop, through cerberus mcp or the built-in agent's own tools.
  • Limits. By default, two levels below your session, four open children per session and eight open sessions in a tree. A spawn past a limit is refused.
  • Approval, if you want it. With require_approval on, each child waits in the queue until you approve or reject it.
  • Only its own tree. A parent sees and steers only its own descendants. It cannot type into a child's terminal or answer a child's approvals.
  • See the tree. The sessions list puts children under their parent, and a session's Flow tab draws the tree with the models each one used.
Example: one task, four helpers
agent.spawn: max_depth 2 · max_children 4 · max_total 8 · require_approval on
  • Refactor the config loaderdepth 0 · running
    • Write tests for the loaderdepth 1 · passed
    • Port the old keysdepth 1 · running
      • Check the migrationdepth 2 · running
    • Update the docsdepth 1 · needs approvalApproveReject
05 · LLM chat

A chat that can do things, and asks first.

The desktop LLM chat, in any browser. It talks to any model the gateway serves, local or cloud, and keeps running when you close the tab.

  • Tools on your machine. The model can read files, search and run commands in the folder you pick. Anything that changes something shows a card first: allow once, allow for this session, or deny with a note.
  • Four modes. Ask me, Auto (read-only commands run on their own), Accept edits, and Plan.
  • Pick up where you were. Recent chats with search; chats from the desktop app open read-only or continue here. ?? gives a quick one-line answer.
  • A mascot, if you like. Eleven of them, drawn in text, reacting to what the model does. Try them here: this is the code the app runs.
06 · The web UI

Made for a phone first, roomy on a desktop.

The UI is built into the binary and does no work while it is closed. Tap a picture to see it full size.

The wall: every agent at once, the waiting ones flagged.
A session on a phone: answer the agent with quick keys.
The bell: approve from any page.
Sessions: what needs you first.
LLM chat: the model asks before it runs a command.
07 · Also in the box

The small things that make it work from a phone.

Drop files

Drop, paste or pick files (the camera too, on a phone) and they land in the agent's inbox/. Other Carino pages can hand files over.

One bell

Finished, failed and waiting sessions land in the bell, and on your phone through ntfy or the desktop notifier.

Replay

Each agent run is recorded. Scrub back through the terminal to see what it did and when.

Get models

Pull from LM Studio, Ollama or a Hugging Face GGUF link, with resume, checksums and a disk check. Downloading never loads a model.

Setup snapshots

Each agent run records its agent and version, model and quantization, so cerberus sessions setup A B shows what differed between two runs.

Install as an app

Over HTTPS (your tailnet, for example) the UI installs on a phone home screen and opens offline.

Every option explained

Settings shows each option with its help, checks it before saving and says when a restart is needed. cerberus config does the same in a terminal.

A leaderboard

Which session, agent, model or repo spent the most tokens, money, energy or time this week.

08 · Energy

All the energy goes to the models.

The control plane is built to stay out of the way, and it tells you what the work costs.

  • Quiet when idle. Measured: about 18 MB of memory and 0.01 s of CPU a minute with nothing running, and nothing more with a browser tab open. The page stops its streams and timers when you switch away. Nothing runs a browser engine in the background.
  • Models leave when idle. A model unloads after its idle time, so the GPU drops back to rest.
  • Watts at the wall. CPU, GPU and the rest, kWh per day and month, and what the PC adds to your electricity bill at your tariff.
  • Cost per request. Tokens, tokens per second, joules and money for each request, session, model and repo.
Monitor: watts, kWh and the bill.
09 · Safety

It runs commands for you, so it is locked down.

Treat Cerberus like an SSH login to your own account. The threat model says what it protects, from whom, and where it stops.

  • Private by default. It listens on 127.0.0.1. You add your LAN or tailnet address on purpose, and a token guards everything.
  • One token per device. Pair each phone or laptop with a QR code, revoke a lost one, rotate the admin token.
  • A sandbox for agents. Sessions can run inside bubblewrap, with a command policy for the built-in agent.
  • An audit log and a doctor. An audit log records who did what, and cerberus doctor checks the setup and prints the fix for each problem.
  • Tested route by route. A test walks all 116 routes and checks sign-in, the cross-site guard, what an agent's token may reach, and that every change is audited. Data files are private to your user.
The doctor: each check with its fix.
10 · Install

Build it, answer six questions, start it.

Needs Go 1.26 or newer to build, plus git and bash for sessions. Optional: llama-server, LM Studio, Ollama, and nvidia-smi or the amdgpu driver for GPU readings.

  1. Get the source.
    $ git clone https://github.com/MiguelCarino/Cerberus && cd Cerberus
  2. Build. A static binary in dist/cerberus, no cgo.
    $ make build
  3. First run. It looks at the machine (engines, models, GPU, agents, Tailscale), asks up to six questions, writes the config and prints a sign-in link with a QR code. --yes takes the defaults.
    $ ./dist/cerberus init
  4. Keep it running. Installs the binary in ~/.local/bin and starts a systemd user service.
    $ ./dist/cerberus install-service
  5. Open it. Prints a sign-in link for every listen address. Open it on this machine, or pair a phone with cerberus pair --name phone.
    $ cerberus url
11 · Questions

Short answers.

Why one service instead of separate tools?

Running coding agents in their own git worktrees is a known idea. Cerberus puts it next to the rest: it is a background service you reach from any browser, your phone included; it hosts the models and one OpenAI-compatible gateway, so agents can run on a model your own machine serves; and it measures what each request costs in tokens, money and energy.

Do I need an agent framework on top?

For many jobs, no. A flow gives you a planner, a fan-out to several models or agents, branches, a judge gate and an approval, saved as a file the service runs by hand or on a schedule. It is a fixed list of steps that jump forward, not a general graph, and its templates run no code. When a job needs your own code between the steps, call the /v1 gateway from your program or framework.

Can I use my LLM subscription?

Yes, but only through the vendor's official command-line tool, run as an agent session. Cerberus never proxies a consumer subscription. API keys are different: they go through the gateway, from the vault.

Do I need a particular vendor's software?

No. Everything works with no vendor CLI installed: the built-in agent uses whatever model the gateway serves, local or cloud. Other CLI agents and cloud providers are optional profiles you add.

Which systems does it run on?

Linux first. The code is pure Go with no cgo, so it builds for macOS and Windows today. macOS runs the service and agent sessions, without the Linux-only extras. Windows has no agent sessions yet. A desktop client comes later; until then any OpenAI-compatible chat app can use the gateway.

Do I need a GPU?

Not to start. Cerberus reads NVIDIA and AMD cards when they are there, and plans model loads around free VRAM. Without one, you can run small models on the CPU through your engine, or use cloud models through the gateway with your own keys.

Can I put it on the internet?

Please don't. Keep it on loopback, your LAN or your tailnet, use TLS for anything that is not loopback (for example tailscale cert), and pair each device instead of sharing the admin token. The threat model explains why.