bastion · software factory

A software factory with a built-in oversight dial.

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

Waiting for you2

divide: guard against zeroplanlocal · demo-a · plan ready
close issue #1landlocal · ianparo/bastion · CI green

In progress2

count lines with wcbuildtwo · demo-b · turn 3
subtract: add a docstringreviewlocal · demo-a · 2 line comments

Finished2

multiplystoppedlocal · demo-a · VM gone
subtractlandedlocal · demo-a · 0e30e2f

An illustration of the Jobs page. The jobs that wait on you come first.

The problem

Agents write code fast. Trusting what they wrote is the slow part.

The report isn't the work

An agent can say it finished work that its commits don't hold. The gap shows up in the diff, if anyone reads it.

Rules in a prompt drift

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.

The agent holds your keys

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.

Sessions don't add up

Five agents in five terminals is five things to watch, and nothing says which one is waiting.

The solution

Treat each request as a job, and keep every decision that matters with you.

One board for every job

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.

You judge artifacts, not claims

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.

Rules you can measure

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.

Keys stay out of the sandbox

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.

The oversight dial

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.

plantrusted after many plans
lights-ondark
defineyour checks, mostly trusted
lights-ondark
buildstill reading every diff
lights-ondark
mergestill deciding every merge
lights-ondark
workflow level: dim · at least one step up to the merge waits for a person

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).

The ladder

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.

constraint · tests-kepttold: in the brief · checked: a hook records the breach · enforced: a hook refuses
toldcheckedenforced
capability · write at planask: the call waits for you to allow it once, send feedback, or stop the job
deniedaskallowed

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.

A/B evals

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 toldB · no-wc enforced
refused calls05
review findings20
turns3928
tool calls3317
cost$0.0344$0.0207
grade77

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.

Custom workflows

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.

skillplan
design-notes →
skillbuild
→
commandmake test
→
stagecode review
→
stagemerge

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.

Use cases

What you'd hand to Bastion this week.

Issue to pull request

Clear small tickets from your backlog

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.

issue #1planbuildPR #2CI fixmerge
Review by diff

Steer the work with line comments

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
Your rules, enforced

Hold agents to your repository's charter

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.

refused · rm -f /work/repo/notes.txt
PreToolUse hook · exit 2

The diff is an illustration. The refused call comes from a recorded run.

After the merge

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.

learn · the autofix deleted the requested # TODO: tidy line and the test assertion that checked for it, and pytest still passed
it proposed two constraints and a gate, each quoting the job

From recorded runs: a learn turn on a local repository, and a pull request on a demo repository that merged, deployed nothing, and was reverted.

What it is not

Get started

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.