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.

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.

skep's claims with where each holds and its limit.
ClaimWhere it holdsLimit
The OS sandbox is up before the agent starts; with no usable backend the run is refusedEvery 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 worktreeAny 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 youIn 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 branchesskep'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 recordedThree 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 telemetryAlways. 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 liftsOne 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 tokenOpt-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.

The threat model

Not for everyone

When skep is the wrong tool

Eight cases where something else will serve you better.

You are on Windows

There is no Windows sandbox backend. The backends are Seatbelt on macOS, bubblewrap with Landlock on Linux, and podman.

No command proves the work

Re-verification re-runs what you pin. With nothing meaningful to pin, a confirmed run tells you little, and an external agent will not dispatch at all.

You need reads confined

The sandbox confines writes and masks a list of credential paths. What else your user can read, the agent can read.

You want to pair and watch

skep is built for handing a task over and coming back to a patch. For interactive work, run the agent directly.

Your ACP agent never asks

The ACP governor answers permission requests. An agent in a mode that does not ask is only observed after the fact.

You want a hosted fleet

skep runs on the machine in front of you, and that machine has to be on. It has no cloud runner and no VM pool.

More than one operator

One home directory, one person approving. There are no accounts and no shared approval queue.

You need interfaces that have stopped moving

One maintainer and a young project. Commands and policy keys still change between releases.