Why skep
What skep adds, and what it does not
skep is a local supervisor. It runs a coding agent inside an OS sandbox, re-runs your project's own verify command on the result, and holds the patch for your approval. Here is how that compares with four other ways to run an agent, by mechanism.
The agent's own permission mode
A vendor sandbox or managed settings
A cloud engineer that returns a pull request
A worktree orchestrator
A statement about another product is quoted from that product's own documentation, read on 18 November 2026 and linked where it appears. Products change; the linked page is the authority, not this one.
Compared · 1 of 4
The agent's own permission mode
The agent asks before it acts, or you put it in a mode that does not ask.
What it gives you
In its default mode Claude Code "stops and asks you before most actions that edit files, run shell commands, or reach the network" (Claude Code docs: permission modes). That works while you are there to answer.
For unattended work you choose a mode that does not ask. The same page says
bypassPermissions "disables permission prompts and safety checks", gives its use as
"Isolated containers and VMs only", and says auto mode "does not guarantee safety".
Codex's danger-full-access mode "runs without sandbox restrictions" (Codex docs: sandboxing).
What skep adds
The isolation those modes assume, on your own machine: an OS sandbox around the whole agent process, started before the agent is, and a refused run when no backend works.
Then two things a permission mode has no opinion about: a re-run of your pinned verify command on a
clean worktree, and a patch that waits for your approval on a skep/* branch.
Compared · 2 of 4
A vendor sandbox or managed settings
The agent's vendor ships its own OS sandbox, and settings an organization can enforce.
What it gives you
Claude Code's sandbox is "a boundary that the operating system enforces around the shell commands Claude runs on your machine". Its documentation says the sandbox "covers shell commands only", and that a sandboxed command has "read access to the entire computer, except certain denied directories" by default (Claude Code docs: sandboxing).
Codex has a workspace-write sandbox mode (Codex docs: sandboxing). For an organization, Claude Code has managed settings: "Nothing in your own settings files or
--settings overrides a managed key" (Claude Code docs: settings).
What skep adds
The same kind of OS wall (Seatbelt on macOS, bubblewrap with Landlock on Linux) around the agent process itself, with one configuration for Claude Code, Codex, Aider and pi.
A secret floor that masks credential paths and the engines' own logins inside the sandbox, a run that is refused when the sandbox cannot be built, and the two steps a sandbox does not have: re-verification and a held patch.
Compared · 3 of 4
A cloud engineer that returns a pull request
The agent runs on someone else's machines and hands back a branch.
What it gives you
In Claude Code's cloud sessions "each session runs in an isolated, Anthropic-managed VM", and "The session keeps running after you close your laptop" (Claude Code docs: cloud sessions). In Codex cloud a task "can keep working while your computer is asleep" (Codex docs: cloud).
The work comes back as a pull request, which is where your CI runs. For Copilot's agent, GitHub documents one more gate: "By default, GitHub Actions workflows will not run automatically when Copilot pushes changes to a pull request" (GitHub docs: reviewing Copilot's pull requests).
What skep adds
Not the verification. A cloud engineer's pull request already runs your CI, and skep re-runs one pinned command.
What skep adds is where the run happens: on your machine, with your keys, inside a wall you configure. The repository does not have to live on a code host, and the evidence stays in files on your disk.
Compared · 4 of 4
A worktree orchestrator
Several agents at once, each in its own git worktree, so their edits do not collide.
What it gives you
Parallel sessions that do not overwrite each other. Claude Code's --worktree flag starts
a session in its own worktree, and its documentation says worktrees "isolate file edits" (Claude Code docs: worktrees).
That is organisation, not confinement. The same page says of its isolation checks that "a command
that writes into the main checkout without running git there, such as cp or a shell
redirect, isn't refused by them", and leaves that to permissions and sandboxing.
What skep adds
Every skep task also gets a disposable worktree, and the sandbox confines the agent's writes to it and a few paths the run owns.
The patch is taken against the commit the task started from, re-verified on a second clean worktree, and lands only through approval.
In one table
What skep claims, and the limit of each
Each row is checked against the code. The middle column says where the claim holds; the last says where it stops.
| Claim | Where it holds | Limit |
|---|---|---|
| The OS sandbox is up before the agent starts; with no usable backend the run is refused | Every sandbox-mode run. Claude Code, Codex, Aider and pi are always in sandbox mode. | skep's own worker can run in workspace mode, which has no OS wall. Reads are mostly open. No Windows backend. |
| skep re-runs the project's pinned verify command on a clean worktree | Any project with a pin. A project run of an external agent is refused without one. | As strong as the command. An unpinned project falls back to the worker's own command, and the record says so. |
| Your default branch never moves without you | In your own checkout, always: it moves only through actions that raise a confirmation. A clone skep manages for you is fast-forwarded to origin before a run; skep never commits to it. | Landing a patch needs approval by default, not always: two opt-in lanes land a re-verified patch on a skep/* branch. |
| A worker cannot push, pull, fetch or switch your branches | skep's own worker: hard denies that no grant lifts. External agents: the sandbox. | git add and git commit can be granted inside the disposable worktree. skep itself pushes a landing branch when you ask. |
| Runs, decisions and approvals are recorded | Three records: the decision log, the run store and per-run audit files. | Plain local files, rotated and not tamper-evident. An external agent's individual tool calls are not recorded. |
| No skep account, no skep service, no telemetry | Always. State lives in a directory on your machine. | Outbound calls go to what you configured or approved. With a hosted model, prompts and code go to that provider. |
| Policy is layered: allow, ask or deny, under a floor that nothing lifts | One engine answers the CLI, the Claude Code hook and the ACP governor. | An unmatched action asks; it is not denied. A role only tightens. A session grant lasts until skep serve restarts. |
| Codex can run on a ChatGPT plan login without the worker holding the refresh token | Opt-in per project, when no OPENAI_API_KEY is set. | The worker holds the access token for the length of the run. skep never refreshes it. |
Not for everyone
When skep is the wrong tool
Eight cases where something else will serve you better.