Saeta is in development and has no public release yet. This page describes the current development build and our plans.

Safe auto mode

Safe auto mode lets an agent work in one project without asking you about every command and edit. It still asks about a short list of risky things, and Saeta's own protections still apply.

Turn it on

In the desktop app, turn it on for a project from the Trust List. A session in the inbox offers it too, for that agent session alone or for its whole project. From a terminal:

saeta auto on            # the project this folder is in
saeta auto on ~/Code/app # or name a folder in it
saeta auto               # show where it is on
saeta auto off

"The project" is the folder's git top-level. Saeta refuses your home folder or the filesystem root as a project. For a project, it covers every agent working there; for a session, only that agent's session.

When you turn it on for a project, in the app or with saeta auto on in a terminal, Saeta asks which folders outside the project the agent may use.

What it allows

Everything in the project that isn't on the list below: editing files, building, running tests, running the project's own scripts. Commands may also use the other projects in safe auto mode, folders you allowed, and the temporary folders while that group is on.

Your rules still come first. Saeta's own protections decide before safe auto mode does, and a rule of yours that also matches the call decides instead of it, whether it allows, asks or denies. Saeta's read-only allows stay allowed. See how Saeta decides.

What it still asks about

It still asks when a call…Rule
deletes filesauto.delete
deletes files, or runs a command on every file it findsauto.find-delete
throws away work in gitauto.git-discard
pushes to a remoteauto.git-push
connects to another machineauto.remote
copies to or from another machineauto.rsync-remote
sends data to a serverauto.upload
runs as another user (root)auto.root
changes who can read or run filesauto.permissions
publishes a package or imageauto.publish
runs a command line hidden inside anotherauto.hidden-command
runs commands a shell reads as it goesauto.shell-input, auto.shell-stdin
runs code written on the command lineauto.inline-code
runs a program read from a pipeauto.piped-code
changes an agent's settings, or what runs laterauto.agent-config
writes into an agent's settings folderauto.agent-folder
edits a file in an agent's settings folderauto.agent-folder-edit
unpacks or applies files without saying whereauto.unseen-write
changes what git runsauto.git-config
writes git's hooks or its settingsauto.git-internals
names a file or folder outside the projectauto.outside-shell
reads a file outside the projectauto.outside-read
edits a file outside the projectauto.outside-edit

This list is read from a copy of the rules Saeta ships (auto.toml) when this site is built. It also asks when it can't read what a call touches (a shell call with no command, an edit with no file), and Saeta's own asks still apply on top: secret-looking files, Saeta's files, an agent's hook settings, git's hooks and settings. Its blocks still block.

Every one of these is high-risk: if nobody answers in time, the call is denied, whatever your fallback setting says. Each question says why Saeta asked, in the words above.

Saeta reads a command as carefully as it can, including every part of cd x && rm y. When it isn't sure where a command writes, it asks.

What it can't stop

  • Scripts and programs in the project run unasked. npm test, make, cargo build or bash scripts/check.sh run whatever they contain. Saeta sees the command line, not what the script, a test or a package's install step does next.
  • It is a guardrail against an agent's mistakes, not containment for a hostile agent. An agent set on getting around it can write a script and run it. A process running as you can change Saeta's settings.
  • Keep your work in version control, so a mistake can be undone.