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.
A signal fails
An agent on the machine reports a fact, for example disk use above 90 percent. A rule opens the incident. code
Triage
A model reads the signal and proposes a severity and a class. A safety classifier checks the output. model, then code
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. modelReport
The report cites evidence IDs. A check flags each claim that has no evidence. model, then code
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


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=yesandRestrictAddressFamilies=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.

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.

Start by watching
You choose the mode for each machine. A new machine is in audit.
| Mode | Kosken reads | Kosken proposes | Kosken runs |
|---|---|---|---|
| audit | Yes | No. It lists candidates. | Nothing |
| shadow | Yes | Yes, with a dry run | Dry runs only |
| live | Yes | Yes | Approved recipes, under your approval rules |

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.