Kosken

Finds the cause. Runs only what is signed.

Kosken is an AI SRE for Linux fleets. It watches your Linux servers, opens an incident when a signal fails, and writes a root cause report with evidence. If a fix is needed, it can run only a recipe that you signed. A model never writes a command.

Free for up to 5 machines. Every machine starts in audit mode: Kosken reads and reports, and changes nothing.

Incident response from alert to fix, in five steps

This is autonomous incident response with limits. Models write text in three of the steps. Code makes every decision that changes a machine.

  1. A signal fails

    An agent on the machine reports a fact, for example disk use above 90 percent. A rule opens the incident. code

  2. Triage

    A model reads the signal and proposes a severity and a class. A safety classifier checks the output. model, then code

  3. Diagnosis

    A model reads evidence from the machine and writes the root cause analysis. It can end with conclude, which takes no action. It has no tool to close an incident. model

  4. Report

    The report cites evidence IDs. A check flags each claim that has no evidence. model, then code

  5. Execution

    The model selects a recipe from a closed, signed catalog. Five gates in code decide whether it runs, waits for a person, or stops. A separate process on the machine runs it and checks the result. code

Kosken incident page for INC-32: the container kosken-e2e-nginx failed on the machine Workstation. The root cause report says the container stopped and the reason is unknown. A person approved docker.start, and the check of the fix passed. Time by stage: triage 3 s, diagnosis 19 s, waiting for a person 17 s, run 2 s, check of the fix 12 s, total 54 s.
The same incident page in the dark theme.
Incident 32 on a test machine of the authors. A container stopped, a person approved the fix, and the page shows the time of each stage.

Where the limits are

Each limit is in code or in the operating system. None depends on a model following a rule in a prompt.

A closed catalog of recipes

A recipe is a signed JSON document. Each step is a fixed list of arguments with typed parameters. No step is a shell string. A model can select a recipe and fill its parameters. It cannot write a new step.

An executor that cannot reach the network

A separate root process on the machine runs the recipe. The unit sets PrivateNetwork=yes and RestrictAddressFamilies=AF_UNIX. It verifies the signature with keys built into the binary. The agent that talks to the server never runs commands.

Three modes for each machine

Audit reads and reports. Shadow shows what Kosken would do. Live runs approved recipes. The default is audit. The effective mode can only go down: a limit at workspace level lowers a machine, and nothing raises it.

Tenant isolation

Row-level security separates workspaces in the database. Each workspace has its own sealed keys, derived with HKDF. You can bring your own model key. Kosken does not issue model keys.

An audit log that shows tampering

Each entry includes the hash of the one before it. A signed anchor is written each day. If someone edits an old entry, the chain no longer verifies.

A person decides

When a gate asks for approval, the request goes to the Approvals page. It shows the recipe, the parameters, the risk, the reasons, and the answers of the Guardian and the safety classifier.

Five gates, all in code

Gate 1 reads the machine mode. Gate 4 checks the recipe, its parameters and the state of the machine. Gate 2 reads the trust of the recipe on that machine. Gate 5 is a safety classifier that never sees the diagnosis. Gate 3 combines the answers. A risk above low, a recipe with no trust on that machine, or a gate that cannot decide sends the request to a person. In live mode, a low-risk recipe that earned trust on that machine can run without one.

Old data asks, it does not refuse

The facts that the server stores about a machine can be old. When only those facts fail, Kosken asks a person and says why. The executor checks the same precondition again on the machine, with live facts, before it runs.

A refused action does not wait in silence

When the gates refuse the action of a diagnosis, the incident goes to a person at once, with the recipe and the reason.

The fix is checked

After a recipe runs, its verify step checks the machine, and Kosken checks that the signals cleared. Only then is the incident resolved.

Measured on a test machine of the authors: a container stopped, a monitor opened the incident, the diagnosis proposed docker.start, a person approved it, and the verify step confirmed the fix. From the stop to the resolved incident: about 90 seconds, 17 of them waiting for the person.

Linux server monitoring with monitors you choose

A monitor is a check that you define for one or more machines. When it fails a number of times in a row, it opens an incident.

What a monitor can watch

A service, a port, a URL, a container, disk, CPU, memory, load, failed systemd units, a log pattern, a certificate, or a read-only command.

Containers

A container monitor checks that a container is up, running, or healthy, or that it did not restart more than a number of times in a time window. The form suggests container names from the inventory of the machine.

Workloads

The Workloads page lists the containers, Proxmox virtual machines and LXC containers, and Kubernetes pods of each machine, with one tab for each machine.

Signals page, Monitors tab, with eight monitors: CPU use, disk, failed systemd units, load, memory, and three container monitors. Each row has Edit, Duplicate, Disable and Delete.
The monitors of the test workspace of the authors.

Tasks and maintenance on a calendar

Tasks run work at a set time without a person at the keyboard. A maintenance plans one change in a time window. A month calendar shows both, with the timers and cron jobs of the machines.

Tasks

A task runs a read-only recipe on a set of machines, or sends an instruction to the chat agent. It runs on a cron schedule, every N minutes, or once, in the time zone that you choose. You can pause it, resume it, or run it now. A task that fails several times in a row shows as "needs attention".

Maintenance

A maintenance is one planned change, for example "install nginx on web-1 on 20 November at 22:00". During the window, the signals of its machines are silenced. At the start, Kosken sends the plan to the chat agent. A change still needs the approval of a person.

The jobs of the machines

The agent reads the systemd timers, the cron files, the user crontabs and anacron of each machine. The Tasks page lists them with the next and the last run, and the calendar shows them next to the Kosken tasks.

Change a job from the list

A row has Pause, Resume and Run now for a timer, and Edit, Turn off and Turn on for a cron line. Each action is a signed recipe and goes through the gates. A cron edit is high risk: another person with write access approves it. The executor keeps a backup of the file and refuses the change if the line changed after Kosken read it.

Read the recipe before it runs

Recipes are the runbook automation of Kosken. Each recipe page shows the steps, the dry run, the check that proves the fix worked, the digest, and the signature state. Anyone who can approve a run can read the same text first.

Recipe page for Restart a service: one step, systemctl restart with a unit parameter, a dry run, a verify step, signed state, and a sha256 digest.
The recipe Restart a service. Demo data.

Start by watching

You choose the mode for each machine. A new machine is in audit.

ModeKosken readsKosken proposesKosken runs
auditYesNo. It lists candidates.Nothing
shadowYesYes, with a dry runDry runs only
liveYesYesApproved recipes, under your approval rules
Machines page with eight demo machines. One is offline, one is pending. Each card shows its mode.
Machines page. Demo data.

One page for the fleet

Fleet management starts on the Machines page. Each card shows the state, the mode, and the last time the machine reported. The page updates by itself when a machine changes.

Your models, one for each agent

You bring your own key for OpenAI, Anthropic, or DeepSeek. Each stage of an incident and each agent of the chat can use a different model, with its own reasoning effort and token limits. An agent with no model of its own uses the model of its stage. Kosken records the tokens of each call, by stage and by incident.

Start with one machine

Connect a machine in audit mode. Kosken reads and reports, and changes nothing. Move it to shadow or live when you trust what you saw. Free for up to 5 machines.

Where the ideas come from

The same author built two earlier projects: OpenRemedy and NanoInfra. Kosken takes ideas from both. The first idea is that the harness matters more than the model. The second is a strict split between the part that reasons and the part that executes. Kosken shares no code with them. The whitepaper lists what we took, what we changed, and where they are stronger.