self-hosted · early access

Fine-tune, evaluate, and ship models as one governed command.

Cost-capped before the GPU spins up. Reproducible from the same inputs and config. Every run audited — who shipped it, what it cost, on the record. Your infra, not a black box.

Join the waitlist Read the docs →
$ curl -fsSL https://cairndev.sh/install.sh | sh

The CLI works today — the waitlist gets you access and release updates as new commands ship.

cairn — dataset gate
$ cairn run dataset-readiness -i ./data.jsonl
› checking · format · dedup · train/eval leakage · pii
› report · 3 findings, each cited to the offending rows
› gate · FAIL · 12.4% train/eval overlap > 5% threshold
✓ run complete · blocked before a GPU spun up · audited · $0.02
Built on LangGraph + Temporal Permissive-licensed Python 3.12+ Self-hosted — your keys, your infra

The failures that hurt are the silent ones.

Cairn turns every silent failure into a loud, gated, audited stop — by construction, on the same command you already run.

Data leakage you find after the GPU bill.

FAIL dataset gate · blocked before the spend

An eval regression that ships because nothing blocked it.

PAUSED model gate · regression · promote held

A model in production and no record of who approved it.

REPLAY who / what / when · on the record

How it works

Declarative in, governed run out — like terraform plan/apply for the work behind AI. You declare the outcome; Cairn drives the tools underneath and leaves a receipt you can retrace.

01

Declare the outcome

A short YAML spec or flags on the CLI — model, dataset, method, budget. No DSL to learn.

02

Get a plan before anything runs

Cairn resolves the GPU provider, training framework, and eval suite, estimates cost, and shows you the plan.

03

Guards enforced where it counts

Cost ceiling before the spend. Promotion paused for a human. Every step written to the audit log. No side door.

04

Replay any run

Every run is content-addressed — its inputs, config, code, and gates. cairn replay reruns it from that exact recipe, on your infra, with your keys.

cost-cappedgatedcitedauditedreplayable
the command changes — the guarantees don't
cairn ask

Ask in English.
Get a governed plan.

The AI plans — cairn picks the pack, resolves the operators, sets the cost cap, and flags the approvals. You confirm; cairn enforces; the run leaves a receipt.

  • ›The model only drafts. The cost cap, PII policy, and approval gate are enforced by the engine — not by the model's good intentions.
  • ›Nothing runs until you confirm. GPU spend pauses for your OK, every time.
  • ›Every plan ends as a receipt. Who asked, what ran, what it cost — replayable later.
cairn — ask
$ cairn ask "fine-tune mistral on s3://data/train.jsonl, under $100, use my infra"
› pack finetune · profile cheap-cloud
› resolves dataset.read→s3 · compute.gpu→your connection · training→qlora · eval→deepeval
› budget $100 cap · est. $62–84 · enforced (BudgetExceeded stops the run)
› policy dataset must pass PII scan before training
› then eval vs baseline → tells you if it's worth shipping
⏸ needs approval · GPU spend pauses for your OK — nothing runs until you confirm
run it → cairn run finetune --dataset s3://data/train.jsonl --budget 100

A platform, not a pile of scripts.

Every workflow is a pack — an installable unit from the cairn registry. Install one and it automatically inherits the cost cap, the gates, and the audit trail — its author never writes a line of that. The core pipeline ships with the CLI; the rest land on the same rail.

The pipeline

ships with the CLI
  • dataset-readinessCheck format, duplicates, PII, and train/eval leakage — block bad data before a GPU spins up.
  • finetuneQLoRA/LoRA fine-tune under a hard cost cap that stops the run, not just warns.
  • evalScore against a baseline; any regression gates the release automatically.
  • promoteShip to your registry or prod — paused until a human approves, on the record.
  • replayRerun or re-render any past run from its hash-chained trace — who ran what, what it cost, who approved. (This is the audit trail — there's no separate audit verb.)
  • doctorPreflight — check operators, bindings, secrets, and providers before a single token is spent.

Optimize

registry · next
  • quantizeShrink a model to 4/8-bit — with a quality gate so accuracy loss stays within a bound you set.
  • distillTrain a smaller, cheaper student model from your big one, gated on matching its quality.
  • prompt-optimizeAuto-tune prompts against your own eval suite instead of hand-tweaking.
  • route-optimizeSend each request to the cheapest model that still meets your quality bar.
  • inference-cost-optimizeBatch, cache, and right-size serving to cut cost per token.
$ cairn install optimize/quantize

Data, safety & RAG

registry · next
  • decontaminateStrip benchmark and eval data out of training sets so your scores are real.
  • align (DPO) · rlhf-dataBuild preference datasets and align the model to them.
  • redteam · guardrail-evalAttack your own model with adversarial prompts — find jailbreaks and unsafe outputs before users do, and verify the guardrails hold.
  • rag-build · embed-evalBuild the retrieval pipeline and pick the embedding model that actually retrieves best on your data.
  • canaryRoll a new model out to a small slice of traffic; auto-rollback the moment metrics regress.
  • model-cardGenerate the documentation of what the model does, and where it fails.
$ cairn install safety/redteam

Anyone can publish a pack — operators are pluggable and sandboxed by trust level (see the pack docs). Want a say in what ships next? Join the waitlist.

Why not the tools you already know?

vs. SageMaker / Vertex

A quarter to onboard, a ticket per GPU, lock-in. Cairn is one command on your own infra, today.

vs. notebooks + bash

Fragile, irreproducible, no record. Cairn is governed and replayable — every input, config, and decision on the record.

vs. W&B / MLflow

They track metrics — they don't enforce a cost cap, gate a promotion, or block a bad dataset. Cairn governs, not just observes.

Questions a skeptic asks first.

Does any of my data leave my infrastructure?
No. Cairn runs entirely on your infra — your keys, your GPUs, your logs. Nothing leaves your perimeter, and there's no phone-home telemetry in the CLI.
What does it cost?
The CLI is free to run during early access — you pay only your own compute providers. The source opens up at public launch (license being finalized); hosted/team features may come later.
Do I need to run Temporal?
Not to start. Runs execute in-process by default; Temporal is the opt-in path when you want durable, long-running remote execution and Slack approvals.
Is this an AI agent making decisions for me?
No. Cairn is a deterministic execution layer. When you use cairn ask, the AI only drafts a plan — you confirm it, and the cost cap, approval gate, and audit trail are enforced by the engine, not the model.
How locked in am I?
Profiles bind capabilities to providers, so the GPU vendor, training framework, and eval suite are swappable. Your policies, audit history, and replayable runs are yours — re-rendered any time from their hash-chained trace via cairn replay.
Should I really pipe curl into sh?
Fair question — the install script is short and auditable, and you can read it first: curl -fsSL https://cairndev.sh/install.sh | less. Or install from source via the docs.

Follow the releases.

New commands and packs ship on a public roadmap. One email when they land — that's it.

No spam — releases and early access only. Or open the full form (role & pack interest).