Paeon

Nothing leaves the pad until you say Go.

Paeon sits next to your alerting. A cheap model triages, a strong model investigates with tools that can only read, and then it asks you. Plain code does the rest, from a closed catalog of actions.

Quickstart Watch the flow

Self-hosted · Apache-2.0 · alpha. Out of the box it takes no action on your server.

Incident #3 · slo_traefik_5xx · server-1

Simulated
  1. Recordtwo alerts, as they cameGo
  2. Correlatesame host, seconds apart: one incidentGo
  3. Triagereal, 86% sureGo
  4. Investigatemedia-server lost its database connectionsGo
  5. Planrestart_container(media-server)Go
  6. Youwaiting for your answerHold
  7. Executornothing runs without GoStandby

The poll holds on you. Lift the guard, then answer.

The poll, station by station

An incident is called through these stations. Each one has a single voice: code that records, a model that only thinks, or you.

Record

Code

OpenObserve, uptime-kuma and anything that speaks the Alertmanager webhook. Every observation becomes one event in an append-only SQLite log. Paeon gets a copy: it is never in the path of your alerts.

Correlate

Code

The same alert firing again is the same incident. Alerts on the same host within minutes join it. Flapping and maintenance windows are flags, and nothing is dropped.

Triage

Model

One call to a cheap model, with no tools: noise, transient, known issue or real. Recorded in shadow mode, so nothing acts on it. A model that is down, unsure or over budget means the incident is treated as real.

Investigate

Model

A strong model with tools that can only read, each behind an allow-list you wrote: logs and metrics in OpenObserve, container state and logs through a Docker proxy, your runbooks and past postmortems. It hands in a root cause, and every claim is tied to the tool call behind it.

Runbook

Code

A known alert with a known fix skips both models and goes straight to the executor: fast, free and deterministic. If its steps do not fix it, the investigator gets the incident.

Plan

Code

A plan is a list of actions from the closed catalog, proposed from the analysis or from a runbook. Anything in the analysis that is not a catalog action stays a sentence for you.

You

You

Go or No-go, on your phone. The button is a signed link from the executor: it works once, for thirty minutes, for that exact plan. Opening it never applies anything. No answer means nothing happens.

Executor

Code

A second process with its own credentials. It checks the plan against its own copy of the rules, takes a lock, applies the step, waits for the container to be running and healthy, and rolls back where there is an inverse.

Postmortem

Model

Once the incident has stayed resolved, a markdown draft: the timeline comes from the event log, a model writes the prose, and the file says status: draft until you review it.

How it works, in full

Flight rules

Paeon assumes that alert text and log lines are written by an attacker, and that the model will eventually be wrong. These rules hold either way.

The model proposes. Code disposes.
No shell, no free-form command and no write credential for a model, in any stage. The only part of its output that code can ever run is a step that names one catalog action on one allowed container.
Two processes. Two sets of keys.
The core reads untrusted text and talks to models, so it holds nothing that can act. The executor holds the one write credential, and believes only its own rules and a link you tapped.
Tools only read.
A log stream, a metric or a container you did not list cannot be read. What is read is bounded, scrubbed of secret-shaped strings and recorded in full.
Triage fails open.
A spent budget never hides an alert. Budgets per incident and per day, a storm guard per hour, limits on tool calls and time.
Never in the path.
Your existing notifications stay exactly as they are. Run Paeon next to your alerting, never instead of it.
Everything is an event.
Every alert, decision, model call with its cost, and tool result is one line of the log. Incidents, the digest, the console and postmortems are read from it.

What leaves your server The threat model

Four levels, and you set the dial

Acting is off until you add the executor on purpose. Then each alert, action and container gets a level, in your rules file. Turn the dial to see what each one does.

Suggest

Paeon tells you what it would do, with no button. The plan is in the analysis; running it is up to you.

What runs: nothing

Auto is earned, one action at a time

After five approved, verified runs in a row of the same action on the same container for the same alert, Paeon shows the policy line that would let it run alone. Adding it is your commit. One failure, one Undo or one “This was wrong” takes it back, and a kill switch drops everything to observe.

Hold Built and covered by tests, not yet proven in long use on a real server.

Acting: approvals, runbooks and earned autonomy

The catalog is closed

Six actions exist. Your rules file switches them on for the targets you name; it cannot add one. Anything else in a plan stays a sentence for you.

Action catalog · six positions

  1. restart_containerRestart one container you listed.In catalog
  2. start_containerStart one that stopped.In catalog
  3. unpause_containerUnpause one that was paused.In catalog
  4. reattach_network_aliasPut a container back on its network alias.In catalog
  5. coolify_restartRestart a Coolify resource you named.In catalog
  6. config_changeNever applied: one existing value of one YAML file becomes a pull request. Merging it is the approval.Proposed
  7. Position sevenThere is no seventh switch, and no way to wire one from a prompt.Blanked

Watch one incident, from the alert to the fix

Three short videos, drawn in your browser frame by frame over a synthetic voice, with subtitles and chapters. Every incident in them is fictional.

On a phone, use Fullscreen and turn it sideways.

The record, rendered

The console is the event log made readable: what was taken into account, which model or tool was called and why, what it cost, and what was sent or done. It can stop automation. It cannot approve a plan.

The incidents board: a count per stage, then incidents grouped by the stage they wait for
The real console, on synthetic data. No real server, alert or model answer is shown.

A tour of the console

Count down to a first incident

Six steps on one machine, with Python 3.12 and uv. No account, no model key. Nothing leaves your machine: without a rules file that enables a stage, Paeon calls no model.

  1. T-5

    Get it

    git clone https://github.com/mmornati/paeon.git && cd paeon && uv sync
  2. T-4

    One secret, and the console on

    echo "PAEON_INGEST_TOKEN=$(python3 -c \
      'import secrets; print(secrets.token_urlsafe(32))')" > .env
    printf 'ui:\n  enabled: true\n' > paeon.yaml && echo "PAEON_CONFIG=paeon.yaml" >> .env
  3. T-3

    Start it

    set -a && . ./.env && set +a && uv run paeon serve
  4. T-2

    Send a first alert, from a second terminal

    set -a && . ./.env && set +a
    curl -X POST http://127.0.0.1:8080/ingest/alertmanager \
      -H "Authorization: Bearer $PAEON_INGEST_TOKEN" \
      -H 'Content-Type: application/json' \
      -d '{"alerts": [{"status": "firing", "fingerprint": "demo-disk-full",
           "labels": {"alertname": "DiskFull", "severity": "warning", "instance": "server-1"},
           "annotations": {"summary": "/ is 95 % full"}}]}'
  5. T-1

    Read what it recorded

    uv run paeon incidents
  6. T-0

    Open the console

    The incident is waiting at http://127.0.0.1:8080/ui.

The quickstart, step by step With Prometheus, Alertmanager and Docker

Hold points

What is not there yet, said plainly.

Roadmap and limits as built

Go for quickstart?

Go No-go: show me the threat model