Self-hosted · source available · no phone home
BosunCadre can handle any AI automation task. You configure the pipeline.
Work is described as a pipeline of configurable stages — scope, brief, execute, review and land. Stages beyond those five, and gates of your own, are on the roadmap, not shipped today. Meanwhile the GPU that sits idle 22 hours a day gets a job: one coordinator holds a queue, and every machine you own — the gaming rig, the NAS, the Pi on the shelf, the laptop you retired — claims the jobs it's actually capable of. Drafting on a local model can cut what you spend on a frontier model, depending on your hardware and models. A paid model checks it, if you want one. Nothing merges until you say so.
Patent pending — the coordination method described above
# installs to ~/.local/bin, checksums verified. no Go, no git, no Docker. $ curl -fsSL https://acribayiksynapsis.com/install.sh | sh $ bosun task add "fix the flaky parser test" --caps can-execute queued 7f3a91 → workshop-pc claimed it 4s later $ bosun board workshop-pc fix the flaky parser test drafting gpu-box render turntable, 240f running pi-4 scope ticket ENG-402 drafting — payment retry logic reviewed · awaiting you
What counts as a worker
A worker is an AI agent. The people are free.
Your tier counts workers, and a worker is every registered AI agent — a session seat or a runner. The people using it are never counted, however many of you there are. A worker that goes offline still holds its slot — the count is what you have registered, not what happens to be running right now. Retiring one with bosun workers rm frees its slot at once.
Workers aren't fussy about what they run on, and the machines don't have to match. Each one advertises what it can do — a GPU, a display, the ability to run your test suite — and only takes jobs that fit.
x86 desktop
The gaming PC
Runs a local model and does the drafting. The single most useful box most people already own and don't use.
GPU box
Nothing installed
Driven over SSH for renders and other GPU work. Files go out, results come back, and you install nothing on it.
arm64
Pi and SBCs
Builds are published for arm64. A small board is a perfectly good runner for jobs that don't need a GPU.
macOS
The laptop
Linux and macOS, amd64 and arm64 — the installer takes care of picking the right build. Windows: amd64 and arm64 downloads, untested. Manual install only.
Measured, not estimated
Let the free model write it. Pay only to check the answer.
Generating output is the expensive part of any paid model. Checking finished work costs a fraction of it. So generation runs on your hardware with no per-token charge, and the paid tokens go on the review — where they buy the most.
local generates · paid verifies · you approve
These are our own test results, not a projection: measured against a paid Opus 4.8 key on real tasks, with each result graded pass or fail by a check that doesn't care which model wrote it. Your results can differ with your hardware, your models and your work.
| Task | Paid model direct | Local draft + paid review | Saved in our test |
|---|---|---|---|
| light | $0.116 | $0.022 | 80.9% |
| moderate | $0.159 | $0.030 | 81.0% |
Source: our A/B run ab-suite-2026-07-18, local qwen3.6:27b drafting and paid Opus 4.8 reviewing. The table shows the two of its three bug-fix tasks that both approaches completed correctly; savings are counted only on those, so work the local model gets wrong saves nothing. These figures show what is possible, not what is guaranteed.
Size is a separate problem from cost, and it gets a separate answer: work too big to finish in one pass is cut into small ordered pieces the local model can manage. Each piece is applied, tested and reviewed on its own, so a long job carries on across steps instead of stalling halfway.
What it already does
Run start to finish on real hardware. None of this is planned.
Real local models, a real graphics box over SSH, a real repository, real files. Planned work has its own heading further down, and stays there.
The work
Finds the models you already have
It discovers what's installed on each machine, so you don't tell it twice, and routes each job to a machine and model that suit it.
Works with
Works with any model behind an OpenAI-compatible API, such as llama.cpp's server, plus Ollama and Anthropic's API directly.
Its own branch, built and tested
Writes the change on a branch, then builds and tests until it passes. A reviewer checks it. You approve it. Nothing merges on its own today.
Renders over SSH
Sent to your graphics machines. Works even where there's no repository involved.
Two workloads, one card
A model and an image tool share a GPU without fighting over it — memory is handed between them, so one card does several kinds of work instead of falling over.
Yours, and staying that way
Licenses don't phone home
A license key activates your install, and your tier counts AI-agent workers — the people are free. Validated offline, applied to a running system without a restart, and it never phones home: no callback, no usage beacon.
Credentials encrypted at rest
AES-256-GCM, with the key that opens them kept outside the database and outside its backups.
Runners update themselves
Runners pull new builds from your own coordinator, and you can turn that off. The coordinator can follow a channel you choose, including our distribution server; it is off until you set one.
Read the source
Source-available under the Business Source License 1.1, and every version turns AGPL-3.0-only two years after it is first published — so the engine goes open source version by version, on a date you can read off the license rather than wait for. You can check every claim on this page against the code: read the source.
Knowing what it cost
Every job's cost is logged
Including what it would have cost on a paid model — so the saving is a number you can check rather than a claim. It'll run the comparison side by side.
You choose who reviews
Another model, a person, or several in order. They all see the same change and answer the same way — approve or reject.
Configurable AI workflows
The route a job takes is yours to set.
A workflow is the ordered run of stages a job passes through, and you define it — for any kind of AI work, not code alone. Writing, research, support and code jobs all run this way. Stages are drawn from scope, brief, execute, review and land, and you pick the ones a given kind of work actually needs.
Set in the workflow, and on the job
A floor for review
The review stage carries a minimum difficulty, so review goes only to a stronger model
on a strict tier, never to the one that drafted. The one exception is the
solo workflow, where the same worker may review its own draft if it can
reach a different model, and an approval counts only when the review reports a model
different from the draft's.
The capabilities a job needs
A job can require capabilities a worker must advertise before it is eligible — a GPU, a display, the ability to run your test suite. No match, no claim.
What happens when it fails
Each workflow carries one ladder for failures: retry, escalate, or fail the job. You set the answer in advance instead of discovering it.
Who is allowed to review what
A seat can be scoped to particular workflows, so the one reading your support mail is not eligible to review a change to your repository.
Four workflows ship ready to run. Write your own, check it with bosun pipeline validate, store it with bosun pipeline set, then scope a seat to it. Work is ordered per project as a roadmap of slices — and nothing lands until a person approves it.
Straight answer
Shipped, and not yet shipped.
Kept apart on purpose. A roadmap item styled like a feature is how software ends up lying by layout.
Running today
- Coordinator, runners, capability-matched claiming
- Draft → build → test → review → your approval
- GPU and render jobs over SSH, nothing installed on the box
- Job decomposition for work too big for one pass
- Per-job cost, with a side-by-side comparison
- Encrypted credentials, key held outside the backups
- Offline license checks, applied without a restart
- Linux and macOS · amd64 and arm64
- Windows · amd64 and arm64: untested downloads, manual install only
Planned — not built
- Direct peer-to-peer access to your own server from anywhere, via a rendezvous handshake — no port forwarding, no public server, and data would not transit us
- Pausing one worker without removing it
Where your work goes
Precise about the network, not vague about it.
BosunCadre runs on your own hardware. Your repository, your files and your working context stay on your network — the coordinator hands out jobs, it doesn't ship your data anywhere.
If you point it at a paid model to review finished work, that review payload goes to that provider. That's the one deliberate exception. It's yours to switch on or off, and a project can be pinned so it never happens for that work at all.
We put it this way because the absolute version isn't true, and anyone who reads their own logs would work that out in an afternoon. A privacy claim you can check beats one you can't.
Beta
It runs every day on the machines of the person who built it.
This isn't a demo that survives a launch video. BosunCadre coordinates the fleet that builds BosunCadre — the same queue, the same runners, the same approval gate, every day, on hardware sitting in one room.
This is a public beta, and it will run as one for a while. It's new software; you'll find rough edges, and we'd rather you arrive expecting them than be sold something finished and discover otherwise. Tell us what breaks and it gets fixed in the open.
A product of Acribayik Synapsis LLC. We'll only use your email to talk to you about BosunCadre.