Saeta is in development and has no public release yet. This page describes the current development build and our plans.
Organisation policies
Enterprise, early access. This page is for administrators. An organisation can install a signed policy on its computers. Saeta then reads the organisation's rules above each user's own, shows "Managed by" with the organisation's name, and keeps the organisation's rules read-only.
What exists today is the policy file on each computer. A Saeta server with an admin console, enrolment and reporting is planned; there is no date yet.
What a policy can do
- Add rules and groups in the same format as a user's
trust.toml: deny, ask, allow, folders counted as inside, safe auto mode and agent decides. Every id starts withorg., and every organisation group is read-only for users. - Set defaults: groups listed in
defaultssit below the user's rules, as suggestions a user's rule can override. - Turn on managed mode (
allow_user_rules = false): the user's own rules stop counting. - Turn off folder grants (
allow_user_folder_grants = false): the user's folder grants stop counting. - Force a built-in group on or off (
builtin_groups), whatever the user or a project says.
An organisation's block beats everything. Its allow does not beat Saeta's own blocks and protections; see the order. Rules can be marked high_risk, so nobody answering means no.
The files
Install two files in a folder only an administrator can write:
| System | Folder |
|---|---|
| Linux | /etc/saeta/managed/ |
| macOS | /Library/Application Support/Saeta/Managed/ |
| Windows | <ProgramData>\Saeta\Managed\, the folder Windows reports to Saeta, not the %ProgramData% variable a user can set |
org-key.pub: the organisation's Ed25519 public key, one per line ased25519:<base64 of the 32 bytes>.#starts a comment. Several lines are a key rotation: a policy signed by any of them is accepted. The file must be an administrator's: on Linux and macOS it belongs to root and isn't writable by group or others; on Windows it and its folder are owned by Administrators, SYSTEM or TrustedInstaller, and nobody else may change them.policy.json: the signed policy.
The folders are built into Saeta, not read from config.toml. Saeta reads the policy when it starts and on saeta reload; it doesn't watch the folder yet. saeta status shows which organisation manages the computer, the policy version, and any problem with the files.
The policy
policy.json wraps the policy's bytes and their signature:
{ "saeta_policy": 1,
"payload": "<base64 of the policy's bytes>",
"signature": "<base64 of the Ed25519 signature>" }
The signature covers saeta-org-policy-v1 and a newline, then the payload's exact bytes. There is no JSON canonicalisation: what was signed is what is read. The payload is JSON:
{ "format": 1, "org_id": "acme", "org_name": "Acme Corp",
"policy_version": 7, "issued_at": "2026-10-29T10:00:00Z",
"allow_user_rules": true, "allow_user_folder_grants": false,
"builtin_groups": { "builtin.agent-folders": false },
"defaults": ["org.suggested"],
"group": [{ "id": "org.acme", "name": "Acme rules" },
{ "id": "org.suggested", "name": "Suggested" }],
"rule": [{ "id": "org.acme.no-force", "group": "org.acme", "action": "deny",
"match": { "kind": "shell", "program": "git", "has_args": ["--force"] } }] }
policy_version must grow with every policy you issue. allow_user_rules and allow_user_folder_grants are true when left out.
Signing
For now, sign with saeta-policy, a development tool in the Saeta source repository. It is not shipped and keeps the private key in a plain file. The admin console will sign policies with keys it keeps safe.
saeta-policy keygen keys/ # keys/org-key.secret, keys/org-key.pub
saeta-policy sign keys/org-key.secret policy.toml out/policy.json
saeta-policy verify out/ # reads out/org-key.pub and out/policy.json
The policy can be written in TOML, with [[group]] and [[rule]] as in trust.toml. sign prints anything this version of Saeta wouldn't understand.
What users can and can't change
| Default | Managed mode | Folder grants off | |
|---|---|---|---|
| The organisation's groups and rules | Read-only | Read-only | Read-only |
| Their own rules | As usual | Ignored. They can switch them off or remove them, not add, switch on or change them | As usual |
| Switching off Saeta's starting rules | Allowed | Not allowed; ones already off count again | As usual |
dev_allowlist in config.toml | Counts | Ignored | Counts |
| Folder grants, built-in group switches, session grants | As usual | As usual | Ignored, none can be added from the app, the CLI or a phone |
A built-in group the policy forces on or off is read-only. Forcing a group off doesn't remove a user's own grant of a folder in it; turning off folder grants does. Safe auto mode and agent decides are a user's rules too, so in managed mode only the organisation's own count.
config.toml can't loosen a policy. Outside folders, a request still gets what an organisation rule decides. fallback = "allow" becomes a deny for a request an organisation rule sent to a person. While the daemon is down calls are blocked, unless the policy sets daemon_down to "user", which hands the choice back to daemon_down_behavior. A policy doesn't set the timeout yet.
Saeta asks before an agent edits ~/.saeta or stops Saeta, but someone working as the user can change these. A policy is a guardrail for agents, not a lock against the computer's user.
When something is wrong
Saeta keeps the last policy that verified in ~/.saeta/org-policy.json, readable only by the user, with the key it verified with. Once a policy has been in force, a broken, deleted or older one never leaves the computer with fewer rules:
| Key file | Installed policy | In force |
|---|---|---|
| Missing | Anything | No policy: the computer isn't managed |
| Present | Verifies, isn't older than the last one, same org_id | The installed policy, which becomes the kept copy |
| Present | Missing, doesn't verify, older, or for another org_id | The kept copy, with the problem in saeta status |
| Present but unreadable, or not an administrator's | Anything | The kept copy if there is one, checked with the key it recorded, with the problem in saeta status |
| Present | Missing or bad, and no kept copy that verifies | No policy, with the problem in saeta status |
On Windows, if the system doesn't report the folder, Saeta falls back to C:\ProgramData. A missing key there keeps the kept copy, with the problem in saeta status, because a failed lookup must not take a computer out of management.
"Older" means a lower policy_version, or the same version with different bytes. Versions only compare within one organisation, so a policy for another org_id is refused whatever its version, even when it is signed with a pinned key.
A newer policy than this version of Saeta understands is read rule by rule. A rule with a field, a match or an action it doesn't know becomes ask, for what it matches or, when even the match can't be read, for everything in its scope. A deny it can't read is also high-risk. An allow whose match it can't read, and a folder, safe auto mode or agent decides rule it can't read, are left out, because asking about everything would be the opposite of what they meant. Unknown settings are ignored. saeta-policy sign prints each of these, so check a policy with the Saeta version your computers run before you install it.
Leaving management
To take a computer out of management, an administrator removes org-key.pub. At its next start or saeta reload, Saeta stops applying the policy and deletes its kept copy. Removing only policy.json is not enough: the kept copy stays in force.
To move a computer to another organisation, do the same first, including the restart or saeta reload, then install the new organisation's key and policy. Replacing org-key.pub with a key that didn't sign the kept copy works too, since that copy then no longer verifies. A new org_id signed with a key that stays pinned is refused until the kept copy is gone, and so is a change of org_id for the same organisation.
The computer doesn't report this to anyone yet. Once a Saeta server exists, it will report when a computer leaves management, so the console can warn.