Skip to content

Investigate and fix with Nightshift

Nightshift is Seylo’s AI SRE, the part of Seylo that troubleshoots; in the product it is shown with an owl. It works the way an engineer on call does: it reads the failing pods, the Deployment, the previous container’s logs, the events and the release history, decides what to look at next, and ends with what it found and what it would change. It does this from a fixed menu of reads, plus metrics, logs and trace queries it writes itself, within fixed budgets. It follows Seylo’s built-in runbooks and your organisation’s own, written as skills, and it recalls what it learned from earlier alerts in your organisation (memory). Every change it proposes waits for a person unless something an admin allowed on Automation covers it. For the problems it fixes, and the ones it hands to you, see what Nightshift handles.

It is reached from one button on every row of Observability → Alerts: Investigate & fix. For a releaser it starts Nightshift’s run and shows the playbook under it, in one panel below the row. Below releaser the same button shows the playbook only, and on a resolved alert it reads Investigate. For what raises an alert and the rest of the row’s menu, see Alerts. When several related alerts are one failure, Nightshift works them as one incident instead.

Nightshift has its own group in the sidebar, right after Observability:

Page What it holds
Nightshift → Incidents Related alerts grouped into one failure, walked to the service where it started. See incidents
Nightshift → Fixes Every fix Nightshift proposed, on alerts, incidents, the readiness campaign and APM coverage, with its status. See Nightshift’s fixes
Nightshift → Skills Your organisation’s runbooks, and Seylo’s core runbooks below them. See skills
Nightshift → Memory What Nightshift learned from earlier alerts and incidents. admin only. See memory
Nightshift → Autonomy A one-line summary of what may run on its own, and the grants that name a Nightshift action, read-only. The controls are on Operate → Automation. See what runs unattended
Nightshift → Settings Nightshift’s model, which clusters it works on, when it starts on its own, how far it reads during an incident, pull requests, what a generated fix may change, and memory’s state

These pages were under Admin → AI settings before 0.4.0. That page is gone; a bookmark to it opens Nightshift → Settings. The coding agent’s model moved to Build → Coding agent, and Nightshift → Settings links to it for an admin.

Every Nightshift page can be read by a viewer, so everyone can see what Nightshift may do. Each control keeps its own role:

Action Role
Read a finished investigation, an incident, the fixes, skills and runbooks, autonomy and settings viewer
Start an investigation, of an alert or an incident releaser
Approve a proposed change to a workload (restart, scale, resources, roll back, delete a pod, a generated fix) releaser
Approve recreating a volume claim approver, with the claim’s name typed. See recreate a claim
Approve a proposed node action (cordon, uncordon) admin
Choose Nightshift’s model; switch it on or off for a cluster; change when it starts and how far it reads during an incident; allow commands in containers; write or connect skills; disable a core runbook; read and manage memory; turn on autonomy admin

Most organisations have several clusters, and Nightshift should not work on all of them: you may want it on development, QA and staging, and kept away from production. Nightshift → Settings → Clusters lists every cluster you can see, with On or Off for each and why. Every cluster starts On, including a cluster you connect later.

On a cluster switched off:

Stops Investigations, of alerts and of incidents: none when an alert fires, and none when someone presses Investigate & fix. Looking for fixes: when an alert fires, each time it is seen again, and when someone asks. Fixes applied on their own, under a standing grant or earned autonomy. Instrumenting a workload for tracing under a grant
Does not stop Alerts. They are still raised and shown, exactly as before. Fixes already waiting for approval also stay with the approvers: approving one is a person’s decision, not Nightshift’s

In short, Nightshift investigates nothing, proposes nothing and applies nothing there, and you still see when the cluster fails.

  1. Open Nightshift → Settings and find the Clusters card (admin).
  2. Choose Switch off on the cluster’s row. The dialog lists what stops and what does not.
  3. Optionally, give a Reason, up to 300 characters, for example production: change board only. It is shown to anyone whose action is refused on that cluster.
  4. Choose Switch off.

Switch on turns it back on at once. Neither needs an approval: off only narrows what Nightshift may do, and on gives back only what your organisation’s other Nightshift settings already allow. Every change is written to your organisation’s audit log, with who made it, when, and the reason.

Everyone can read the card. The Why column says who switched a cluster and when, or On by default. for a cluster nobody has changed.

Investigate & fix is refused, with a message that names who switched the cluster off, when, and the reason, for example:

Nightshift is switched off for cluster prod-eu by ana@acme.example on 2026-11-07 ("production: change board only"). It does not investigate there; alerts are still raised and shown. An admin turns it on under Nightshift > Settings > Clusters.

When an alert fires there, the alert says that Nightshift did not start on its own, and why, naming who switched it off and the reason.

A cluster you remove and add again under the same ID keeps its switch, so a cluster that was off stays off.

When an alert starts firing, Nightshift reads the evidence and proposes a fix without waiting for a click. An admin chooses when, under Nightshift → Settings → When an alert fires:

  • Automatic once a model is set (the default);
  • Always;
  • Only when someone presses Investigate.

Starting an investigation never changes your cluster - it only proposes. You can always start one yourself with Investigate & fix on the alert, unless an admin has switched Nightshift off for that cluster. When Nightshift did not start on its own, the alert says why.

Automatic investigations are bounded per organisation. The defaults are the same for every organisation:

Limit Default
Runs at a time for one alert 1
The same alert again At most once every 6 hours, except once more after a fix on its workload is verified
Per cluster 4 an hour
Per organisation 10 an hour, and 40 a day

A problem that comes back after a verified fix is a regression, not a flap: something put it back. So a fix that verified after the alert’s last run lifts the 6 hours once, and the alert is investigated again; the other limits still apply.

A limit stops only the automatic start; Investigate still runs one by hand. When a limit is reached, the alert says which one, for example:

40 automatic investigations in the last 24 hours, at the organisation's daily cap of 40. Press Investigate to run one by hand, or ask for a higher limit under Help > Contact support.

Need more? Ask Seylo through Help → Contact support (see get help). Seylo can raise the daily, hourly and per-cluster limits for your organisation; an organisation’s own admins cannot raise them. The 6-hour wait for the same alert does not change. The (i) beside When an alert fires on Nightshift → Settings shows your organisation’s numbers, and, when Seylo changed them, the date and the reason given.

When an alert belongs to an incident, Nightshift runs once for the incident, not once per alert. The run starts on the incident’s anchor - the alert of the service the incident’s walk named as the root, or else its earliest open alert - and reads across the incident’s namespaces. The other alerts’ own runs are skipped, and each says so: Part of incident ...: Nightshift investigates the incident once, not each alert, .... The same limits apply to an incident’s run.

With no model configured for Nightshift, Investigate & fix gathers the evidence and stops there: the diagnose rules’ findings, the changes Seylo made in the same namespace before the alert, the crashed container’s last log lines, and the metrics and logs around the alert when the observability chart is installed. Every item is numbered and redacted. The panel says so: No model is set for Nightshift in this organisation (Nightshift > Settings), so only the deterministic layers above ran.

An admin chooses the model on Nightshift → Settings, under Nightshift’s model, one of two. Everyone else sees whether one is set.

  • Seylo’s model (the default). The page names the model; its tokens for investigations are included in the price of a verified fix. On portal.seylo.in it is GLM-5.3, run on Azure AI Foundry in Azure’s US Data Zone, and the page shows it as GLM-5.3 on Azure AI Foundry (US Data Zone). Each Seylo service has its own model configuration, so check the name the page shows. If your Seylo server has no model configured, the page says so and offers only your own key.
  • Your own key. Choose the provider, paste the key, press Verify key, pick a model and Save; saving tests it. Where to get a key for each provider is in choose the model. Choose this if your evidence should go only to a provider you have an agreement with.

Seylo’s model is the default unless your organisation saved its own key before it made a choice: then your own key stays in use until an admin chooses otherwise.

Neither choice silently falls back to the other. If Seylo’s model is chosen but your Seylo server has none, and your organisation saved its own key, Nightshift uses that key and the page says so. Nightshift and the coding agent each have their own model configuration; neither ever uses the other’s. The key is write-only: it is never shown again, by the page or the API. See how secrets are handled.

The same choice answers Seylo’s in-page assistants: Ask AI on the Metrics and Logs pages, and Build with AI on dashboards. They send the model metric and field names and your question, never your data.

An assistant’s question runs in the background. While it runs, the page shows Asking <model>... with the seconds so far and a Cancel button, and you can leave it running; the answer ends with Answered in <time> by <model>. An organisation can have 4 assistant questions waiting for the model at once. A fifth is refused with a message that starts Your organisation already has 4 assistant requests waiting for the model: wait for one to finish, or cancel one you no longer need.

With a model, Investigate & fix starts a run and the panel under the alert fills in as it goes:

  1. The evidence above, gathered first, exactly as without a model.
  2. Opening reads every engineer makes: the workload’s pods, its Deployment, its release history, and what changed. These also record the current values a proposed change would start from. When a probe is failing, one more: the cluster’s network, so a NetworkPolicy that nothing enforces is ruled out before it is blamed. When the evidence then names a cloud resource, such as a Key Vault or a database, Nightshift reads its settings through your cloud account: see Nightshift and your cloud. When Nightshift’s rules already recognised the failure and filed a fix on the alert, that finding is numbered evidence too, for the run to confirm or refute.
  3. What it can draw on. Nightshift is shown short indexes of what matches the alert: your organisation’s skills, Seylo’s core runbooks, and the most similar past lessons from your organisation’s memory. It opens the ones that fit; each becomes numbered evidence.
  4. Rounds. In each round the model asks for up to three more reads from the menu below, or queries it writes itself, says in one sentence what it is checking and why, and every answer becomes numbered evidence.
  5. The answer: findings, a plan in an SRE’s order - mitigation, fix and prevention - and at most three proposed actions.

The model chooses its reads from this list, and its own queries from the section after it. Nothing else is on offer.

Read What comes back
pods A workload’s pods: phase, readiness, restarts, last termination, node, owner
describe One object, summarised: status, conditions, containers, probes, resources. Kinds: Pod, Deployment, StatefulSet, DaemonSet, ReplicaSet, Service, Endpoints, Ingress, ConfigMap, HorizontalPodAutoscaler, PersistentVolumeClaim, Job, CronJob. Environment variable values are withheld
events Warning events in the namespace, newest first, optionally for objects whose name starts with a prefix
logs The last lines (1 to 200, 80 by default) of a container, or of the instance that crashed
rollout A Deployment’s rollout status
history The releases Seylo recorded for a workload: revision, image tag, when
node A node’s conditions, taints, allocatable capacity and whether it is cordoned
metrics One fixed question over the window around the alert: memory, CPU, throttling, restarts or OOM kills
error_logs Error lines from the log store over the window around the alert
changes What changed in this namespace in the two hours before the alert: what Seylo changed, and objects created outside Seylo. See what changed
network The cluster’s network around the namespace: which engine enforces NetworkPolicy, or that none does (then no policy can be the cause); the namespace’s NetworkPolicies where the agent may read them, and any direction that denies everything; packets dropped by policy where the engine’s counters are in your metrics store; and which controller serves each Ingress. Once per run
dependencies The service map around a workload: what it calls and what calls it, one or two steps out, each edge with how it is known. Read from Seylo’s map, not the cluster. Offered once the cluster’s map is built
cross_cluster For a workload behind an Ingress: where a 5xx is born, hop by hop - the app, this cluster’s ingress, or a front proxy on another cluster or a second ingress layer - why a front proxy fails with the exact annotation to change, and what a migration left behind. Read from the ingress controllers’ logs and the map. At most 2 per run. See across clusters
skill One of your organisation’s skills or one of Seylo’s core runbooks, or a skill’s reference file. Offered only when one matches the alert
memory One past lesson from your organisation’s memory: what was seen, the cause found, the fix and whether it held. At most 3 per run
exec One command from a fixed, read-only list, inside a container. Only on a cluster an admin has opted in. See commands in containers

Nightshift asks “what changed?” first. Seylo’s own record holds only changes made through Seylo, so changes also lists objects created in the namespace in the 2 hours before the alert, by their own creation time: Jobs, CronJobs, Secrets, ConfigMaps, Deployments, StatefulSets, DaemonSets and Services. It also names the Secrets and ConfigMaps the failing workload reads.

  • Secrets by name and time only. A Secret is listed, never read: no key, no value.
  • A likely rotation is flagged. When something with a credential-like name, such as a rotate-db-password Job or a new Secret, appeared just before the alert, and the Secrets the workload reads are older, the run is told a credential may have been rotated on one side only. It is a lead, not a verdict: the run checks it against the errors, such as a rejected password.
  • An edit in place is not seen. A Secret or ConfigMap changed in place keeps its old creation time, and the run says so rather than calling it unchanged.

After its opening reads, the model can also write its own questions. This is for what the fixed reads do not ask: a latency percentile for one route, the log lines that mention one order ID, the spans of a slow request.

Query What the model sends What comes back
metrics_query MetricsQL, over a range or at one instant Up to 8 series, each summarised
logs_query LogsQL Up to 25 log lines
traces_query LogsQL over spans Up to 25 span rows
trace_path A trace ID seen in the evidence, or a service whose recent failing requests Seylo samples One request’s path through your services, where it dropped and why, and its slowest hop - the analysis of follow a request. At most 3 per run
node_health A workload The health signals of the workload and of what it depends on - pools, connections, consumer lag, backlogs, retries, breakers - each judged, with its source. At most 2 per run
k8s_get A kind and a name, or a kind and an optional name prefix The object, or up to 20 objects summarised. Kinds: Pod, Deployment, StatefulSet, DaemonSet, ReplicaSet, Service, Endpoints, EndpointSlice, Ingress, HorizontalPodAutoscaler, PodDisruptionBudget, ConfigMap (its keys only), PersistentVolumeClaim, Job, CronJob, Event, and Node on a cluster-wide agent

Metrics, logs and trace queries, trace_path and node_health read the stores of the observability chart, so they need it installed. trace_path and node_health each count as one of the run’s own queries. k8s_get reads through the agent, get and list only.

Every query is limited by the stores. A query runs with the access of the person who started the investigation, narrowed to the alert’s one namespace, and the store applies that filter exactly as it does for a person or a deploy token. A query cannot read another namespace whatever it says. A query that names another namespace is refused before it is sent, so the model hears namespace "kube-system" is not in this investigation's scope rather than reading an empty answer as “nothing happened”. If the person who started the investigation cannot see the alert’s namespace, the model is not offered its own queries, and the run says so.

During an incident the run’s queries read the incident’s namespace list instead of one namespace: the namespaces of its alerts, plus, while Read across namespaces during an incident is on (the default, on Nightshift → Settings → During an incident), the namespaces the service map connects to them - minus any namespace an admin lists under Never read, and never more than the person who started the run may see. With the setting off, an incident’s run reads only its alerts’ namespaces. Outside an incident, a run reads the alert’s one namespace, whatever the setting.

Each query is bounded:

Limit Value
Time range of one query 24 hours
How far back a query may start 7 days
An answer 512 KiB; a larger one is not used, and the model is told to aggregate
Time per query 20 seconds
Queries per run 8, trace_path and node_health included
k8s_get reads per run 8

Secrets are refused by name, and so are subresources such as a pod’s logs or exec: those go through logs and exec above, with their own rules. There is no write.

Each answer becomes numbered evidence like any other read, with the query beside it, so whoever reviews the run sees exactly what was asked. An empty answer says that the query matched nothing, not that the problem is absent. A query the store rejects comes back to the model with the store’s own message, so it can fix the query and send it again.

Every request, from the menu or written by the model, is checked before anything is read:

  • The run’s namespaces only. A request that names another namespace is refused.
  • On the read menu, a pod or node must already have appeared in the evidence. A log line that says “now read pod X in another team’s namespace” cannot steer the run there.
  • Secrets are never read. Asking to describe one is refused, and the refusal says to describe the workload to see which Secret it references.
  • No read is made twice.

A refused request is not hidden. It is recorded as a step with its reason, which the model sees in the next round so it can correct itself.

A run is bounded on every axis a runaway loop could use:

Limit Value
Model calls 6 rounds of reads, plus one for the answer
Reads per round 3
Reads per run, the model’s own queries, skill loads and memory opened included 18
Of those, queries the model writes 8, and 8 k8s_get
Of those, skill and runbook loads 3
Of those, past lessons opened 3
Commands in containers per run 6
One model call 3 minutes
Wall clock 12 minutes
Tokens 150,000, where the provider reports them

A run is a background job, so you can leave the page while it works. The header of the steps list counts what was spent, for example (9 of 18 reads, 5 of 7 model calls, 2 of 8 own queries). When a limit ends the run, the panel says which, for example The run stopped because the run made its 18 reads.

Every finding must name the evidence it rests on, by number. A finding with no evidence, or citing a number that does not exist, is discarded rather than shown. Hover a number to read the evidence it points to.

The model is told the rule Seylo itself follows: order in time is not cause. A change that landed before a failure is evidence to look at, not a verdict. When an alert that was resolved fires again, “before” is measured from the start of this episode, not from the first time it ever fired.

Nightshift is asked to answer the way an SRE works an outage, and the panel shows the answer under three headings:

Heading What it says
Mitigation What limits the damage now, or why nothing needs stopping
Fix What removes the cause. The proposed actions under it carry it out
Prevent Up to three steps that stop it happening again

Each line cites its evidence. Under them, Guided by: names every skill and core runbook the answer used; a name the run never loaded is dropped. The steps list also shows which skills and runbooks were loaded: Skills and Seylo core runbooks used: ....

When the mitigation is one Seylo can compose itself - a capacity buffer, a rate limit or maintenance page on an ingress-nginx Ingress, or scaling down another workload - it is filed as a fix that waits for a person, with its checks and its undo. See mitigations. A mitigation is never applied unattended.

When Nightshift knows the cause, its Fix is a remedy you can act on, even when the change is not one Seylo can make. “Diagnosed, nothing for Seylo to do” is never the answer. Under the fix’s sentence, the panel shows:

Line What it says
Where Where the change goes, and the exact object, file or system: In this cluster, In the owner’s Git repository, In the application’s code (with the file and line when a stack trace names it), or Outside Kubernetes - a database, a cloud setting, DNS, another team’s system
Change The exact change: the field and its new value, a diff, or a command, worked out from the current value
How Who applies it: Seylo applies it once a person approves; As a pull request; The coding agent writes it, with a test, as a pull request (with a Start the coding-agent task button); or A person applies it, following the change above
Verified by The signal that shows it worked, for example the errors stopping in a log or an error rate falling

A confidence - high, medium or low - is shown beside the fix. A secret value is never written into a change: the change names the Secret and its key, and says who sets it.

When the fix is in the code, Start the coding-agent task starts the coding agent on it: the evidence, the file and line when a stack trace names them, and a regression test to write. The repository comes from the pod template’s org.opencontainers.image.source annotation, else the Git repository Argo CD or Flux syncs from (which may hold only manifests, and the task says so), else your architecture file. You review its change and open the pull request.

The remedy is what Nightshift recommends; it changes nothing by itself. A change Seylo can make is still filed as a proposed action or a fix that a person approves, and a pull request or a coding-agent task is opened only through those doors. Investigations from before 0.4.0 show the fix’s sentence alone.

An investigation may end with up to three changes, chosen from this list:

Action What it changes Who approves
Restart a Deployment A rolling restart of its pods releaser
Scale a Deployment Its replica count: 1 to 50, at most double the current count in one step releaser
Set resources One container’s CPU or memory request or limit: at most double, at least half the current value in one step releaser
Roll back The Deployment, to the previous revision Seylo recorded releaser
Delete a pod One pod that a controller will recreate (a stuck or wedged replica) releaser
Cordon a node Marks it unschedulable. New pods go elsewhere; nothing is evicted admin
Uncordon a node Marks a cordoned node schedulable again admin

Not on the list, deliberately: an image or environment change (that is a release, with its own review), a ConfigMap edit, a quota, scaling to zero, draining a node, and anything in another namespace. Some of the rule-based fixes cover a few of these, each with its own approval: a quota raise, for example, is always a person’s, and a change in another namespace or in kube-system needs an admin who has release access there.

Beyond this list, Nightshift may also propose one generated change - a probe, resources, a PodDisruptionBudget, an autoscaler and a few more fields - that a five-check guard accepts before you see it. See generated fixes.

Each proposal is checked against what the run actually read before you see it:

  • the target must have appeared in the evidence;
  • a scale or resource change needs the current value to have been read, because the diff would otherwise have a blank where “from” belongs. Seylo never proposes a value it has not read the current value of;
  • a pod with no controller is never deleted, because nothing would recreate it;
  • a rollback needs an earlier revision in Seylo’s own history. Nightshift’s own fixes can also go back to the Deployment’s previous revision in the cluster, for a person’s approval: see rollback.

A proposal that fails a check is dropped, and the panel lists it with the reason. Nightshift proposes no change means none of these actions fits; the findings say what to look at, and the remedy still says what to change, where, and who applies it.

A finished run is kept, redacted, so anyone who opens the alert later reads the same evidence and findings. The panel says when it ran and who asked, for example Nightshift investigated this alert 2 hours ago, asked by ana@acme.example.

Each proposal shows what changes as a diff — the field, its current value and the new one — the reason, and the evidence numbers behind it. Approve does one of two things, and the panel says which:

  • With approvals on (the default), it files an ordinary approval request: Sent for approval as request ... An approver applies it from Approvals; the engine reads it back. It then goes through Approvals like any other change.
  • With approvals off on your Seylo server, it applies the change at once through the same engine, reads it back, and re-checks the alert 90 seconds later. The result appears under the proposal, for example Re-checked ...: resolved.

Every change goes through the same path as any other change Seylo makes: the ownership check, a dry run, the apply and a read-back.

A workload that Argo CD, Flux or Helm owns is refused, and the refusal names the owner. Approving it then needs you to tick I acknowledge this owner and want the change anyway. A reconciler would revert the change at its next sync, so the panel says that too. Such a change is never made unattended. For a workload Argo CD or Flux deploys from GitHub, Nightshift can instead send its fix to the owner’s repository as a pull request.

Under the run, the same panel shows the playbook for the alert: what Seylo would do about this kind of failure, and whether it may do it on its own.

Badge Meaning
can run unattended Applied automatically when a grant covers it; otherwise Fix now (releaser) sends it for approval. Raising a memory limit after an OOMKilled is the main case
needs a person The kind of change Seylo never makes on its own, such as rolling back a release that stopped starting soon after a change, or raising a namespace’s budget (an admin’s click)
explained No safe automatic fix. The steps say what to look at

Most failures — crash loops, image pulls, failing probes — have no safe automatic fix, so their playbook explains. For those, the proposals at the end of Nightshift’s run above, and the fixes it files for the failures it recognises, are the fix you can approve. Every fix, how it is checked and how it is undone is on Nightshift’s fixes.

A run starts when an alert fires, within the bounds in how often it starts on its own, or when someone clicks Investigate & fix. An admin who wants runs only on a click chooses Only when someone presses Investigate under Nightshift → Settings → When an alert fires.

Nothing Nightshift proposes is applied without a person, except in envelopes an admin turns on deliberately, and none of them on a cluster where Nightshift is switched off. Every one of them is on Operate → Automation, under Nightshift fixes it may apply without asking, beside one log of everything Seylo changed on its own and one Pause all automation:

  • Fixes Nightshift may apply. A class of fix that has proven itself in your organisation may run on its own while the organisation’s switch is on, until its end date. See fixes, class by class. Under the table, four fixes run on their own only when their own box is ticked: memory limits sized from evidence (with an optional second step the same day), growing a nearly full volume, recreating a claim that never bound, and probe paths after 3 approved.
  • Grants. An admin requests one and an approver signs it. Its form has a Nightshift actions section. Nightshift → Autonomy lists the grants that carry Nightshift actions, read-only, with Manage on Automation. A cluster that does not answer is named, not counted as having none.

The actions a grant can carry are:

  • Restart a Deployment
  • Delete one controlled pod
  • Roll back to the previous revision (any reason) — never implied; it must be ticked
  • Roll back a crash or stuck rollout to the last release Seylo saw run healthy (within 30 min of the release)
  • Roll back when the new image cannot start (pull fails or name invalid) — the narrow rollback, for an image that never ran
  • Raise a CPU request to measured use + 20% (at most 4x, never above the CPU ceiling you set)
  • Add an HPA where load splits across pods (min = today’s pods, max within your replica ceiling)
  • Cordon a node and Uncordon a node — covered only by a cluster-wide grant (one with no namespace)
  • Instrument a workload for tracing — one OpenTelemetry Operator annotation, only in the grant’s namespace and for the languages it names. See APM coverage
  • Restart a workload whose pods mount an older version of a Key Vault secret than the vault’s current one
  • One-fix grants, each covering one Nightshift fix inside the bound its label states

Each is described, with its bound, on what Nightshift may do on its own.

A scale or resource proposal is covered by the grant’s dimensions and bounds instead. There is no wildcard: a grant signed before an action existed does not cover it.

Under a grant, the same envelope applies as to any unattended change: the grant’s scope, hours, rate limit, cooldown and expiry, and Pause all automation. Every decision, including each refusal, is in Automation’s activity log. A proposal the grant does not cover says why under it, for example Not applied unattended: No standing grant covers shop/checkout-api, so this needs a person.

Never unattended, whatever is allowed: a workload Argo CD, Flux or Helm owns, or one whose owner could not be read; a rollback to a revision Seylo did not record, except for an image that never started; recreating a volume claim that is or ever was bound; growing a volume past the admin’s bounds, or when its cost is unpriced; a mitigation; a generated fix other than a memory limit, a CPU request, a new HPA or a probe path under their own rules; pausing a chaos experiment; scaling a workload back up from zero; a pull request; and a coding-agent task. The full list is on always a person.

  • Read a Secret value. Not through describe, not through k8s_get, not through a command in a container.
  • Act outside the alert’s namespace, except a node action on a node the evidence named, a mitigation a person approves, or an incident’s fix on the service the incident’s walk named. Its own queries are limited by the stores to the alert’s namespace, or during an incident to the incident’s namespace list.
  • Run a skill’s scripts, or gain anything from a skill, a runbook or a memory. A skill is guidance it reads and cites; a past lesson is history it reads and cites. Neither adds an action, a target or autonomy.
  • Run a command you did not opt the cluster into. Commands in containers are off unless both your agent’s install and your Seylo admin allow them. See commands in containers.
  • Write anything not on the action list or on Nightshift’s fixes, or approve its own proposal.