Give Bastion a request. Agents work it through a pipeline in a sandbox, and you choose how closely to watch each step, merge included. It's early: this is 0.1.1, and the Mac app isn't signed with a Developer ID yet.
Rust · iced · on iii 0.25.0 · Apple Silicon Macs and Linux · v0.1.1
An illustration of the Jobs page. The jobs that wait on you come first.
Agents write code fast. Trusting what they wrote is the slow part.
An agent can say it finished work that its commits don't hold. The gap shows up in the diff, if anyone reads it.
A prompt can say "keep the tests," but nothing measures whether the agent listened. So there's no way to tell if a stricter rule helps or only costs more.
An agent that can push and merge has your credentials in its run. And a run that has seen a credential can't be trusted again.
Five agents in five terminals is five things to watch, and nothing says which one is waiting.
Treat each request as a job, and keep every decision that matters with you.
Each request becomes a job with its own worktree and sandbox VM. The Jobs page shows them all, with the ones waiting on you first.
Every stage leaves something you can check, such as a plan, a test result, or a diff. A comment on one goes to the agent as its next brief.
Every rule is a hook decision with a level: told, checked, or enforced. Run an eval to see what a stricter level does before you commit to it.
Agents run in sandbox VMs that never see a credential. Pushes and pull requests happen on the host, and a tamper-evident log records every decision.
Start with the lights on. Turn them off one step at a time.
A new factory waits after every step for you to approve its result or send it back with a note. Each step has its own dial, so as you trust a step more, you turn that one dark and leave the rest alone. A dark step goes on at once. Nothing waits on a timer, and every result and decision goes in the log whatever the dial says.
An illustration. Three presets set every dial at once: lights-on (every step), dim (only the steps that act outside the job), and dark (no step).
Tighten a rule one rung at a time, and keep the record.
Every rule sits on a ladder. A constraint says what a turn must or must not do. A capability says which function a turn may call. Promote one and a hook holds the agent to more; demote it and the hook holds less. Each move is one rung, and the audit log records it, along with the eval you acted on.
From a recorded run: with tests-kept enforced, a build that dropped test_add went back to build with the rule. At checked, the same finding waited for a person.
Try a stricter rule on real requests before you keep it.
An eval runs the same requests twice against the same workspace snapshot: arm A with your current rules and arm B with one change. Each trial stops at review with its diff, so nothing lands. A judge grades every result, and the Evals page shows the difference per request, with a link to each hook decision behind it.
If B wins, Apply B moves the rule to B's rung. The audit log records the move and the eval you acted on.
| A · no-wc told | B · no-wc enforced | |
|---|---|---|
| refused calls | 0 | 5 |
| review findings | 2 | 0 |
| turns | 39 | 28 |
| tool calls | 33 | 17 |
| cost | $0.0344 | $0.0207 |
| grade | 7 | 7 |
A recorded eval of three requests that each ask for a wc count. Three requests is a small run, so read it as one result, not a benchmark. Today an arm changes rule rungs. Each trial also runs its contract, the workspace's gates and the repository's verify.yaml, so a grade sits beside a check that passed or didn't.
Run the pipeline your team already uses.
A workflow is a graph of steps. Each step is a skill, a prompt, a command, or a built-in Bastion stage. Skills come first: a skill step is an agent turn that follows .claude/skills/<name>/SKILL.md from your repository. A command step runs one shell line in the job's VM, such as make test, with no agent, and exit 0 passes.
Links carry results, not conditions. A step declares what it gives, such as design-notes, and the next step gets it in its brief. If a result is missing, a code check holds the step: the agent gets one more try with the reason, then the job waits for a person. Every step keeps its own dial.
An illustration. Bastion ships three built-in workflows (short, full, and full without acceptance tests) and a dozen more to start from. An admin changes any of them on the canvas, or starts a new one from a name. A changed built-in takes the original's place, and reset brings the original back. Each job keeps the version it started on.
What you'd hand to Bastion this week.
Start a job from a GitHub issue. Bastion opens the pull request and links it back. If CI fails, Bastion sends the agent one more turn with the failing log. When you approve the merge, the issue closes.
Read the proposed diff and leave a comment on a line. The agent gets it word for word, and the next diff answers it, with no chat window.
calc.py:5 · "raise on zero"- return a / b+ if b == 0:+ raise ZeroDivisionError("b is zero")+ return a / b
Bastion reads the rules and hooks your repository already has in .claude/settings.json. So a hook that refuses rm refuses it inside the sandbox too.
rm -f /work/repo/notes.txtThe diff is an illustration. The refused call comes from a recorded run.
A landed change still answers for itself.
The pull request carries the plan, the briefing, a UAT script, the proof, and anything you waived. Only the person who asked for the change can sign off its UAT. After the merge, Bastion watches the merge commit's deployment. If a later commit reverts the change, that revert counts as an escape against the job that landed it.
The learn step then proposes rule changes, each with evidence from the job, and when you accept one it becomes a constraint or a workspace gate. So the Verification page can show each landed job with the decisions that let it through and the escapes found since.
# TODO: tidy line and the test assertion that checked for it, and pytest still passedFrom recorded runs: a learn turn on a local repository, and a pull request on a demo repository that merged, deployed nothing, and was reverted.
/dev/kvm.Install the server and the CLI, or add --desktop for the app too. The installer checks each download against the release's signed checksums.
curl -fsSL https://tacoda.github.io/bastion/install.sh | sh curl -fsSL https://tacoda.github.io/bastion/install.sh | sh -s -- --desktop
Or use Homebrew. The cask adds the app, and the window's command, to what the formula installs.
brew install tacoda/bastion/bastion brew install --cask tacoda/bastion/bastion
On a Linux VM or VPS, --service runs the server as a systemd user service. The host needs /dev/kvm for the sandbox VMs.
You also need iii 0.25.0 and a key for one model provider, which you add in Settings. Start the app or bastion-server. If something is missing, Doctor names it and says how to fix it. Later, bastion update installs a newer release once its signature checks.