Protect the job that can't fail.
Without rewriting it.

Settlement runs, billing batches, regulatory exports — the work a company actually cannot drop — still run on cron, SQL Server Agent and Task Scheduler. Not because nobody cares, but because everything that would govern them properly asks for a migration first. Weev asks for one agent install.

01 · The cost of adoption

1 hr

from agent install to first evidence, on a read-only change ticket

0

jobs rewritten — the code that runs tonight is the code that ran last night

0

inbound ports, new queues or schedulers to stand up or migrate onto

4

rungs per job — Observe, Adopt, Own, Native — each with mechanical rollback

That is the entire cost of adoption. What you get back is below.The Weev agent · Upcoming

02 · The alternatives

Every alternative asks for something you can't give

Teams don't leave settlement on cron because they don't care. They leave it there because the exit price is too high.

Asks for a rewrite

Rewrite-first frameworks

Temporal, Inngest and friends are excellent — once your settlement run is rebuilt inside their runtime. For jobs that move money, the rewrite never gets scheduled. And work that was never a service in the first place, like a script on a locked-down host, never moves in at all.

Asks for an ops team

Enterprise schedulers

Control-M-class tools govern everything and belong to an ops team. Developers file tickets to change a dependency they wrote.

Asks you to remember

Cron and runbooks

The default. Dependencies live in comments, retries live in a wiki, and the first sign of failure is a missing report.

Asks for one agent install

Weev

Observe first: the jobs stay where they are and every run becomes a record. Then each job escalates at its own pace, and the dependencies, the schedule and the reason it ran become explicit, validated and visible.

When a job is ready to be declared, the SDK is there today and one weev.yaml is coming — the deepening layer, not the price of entry.
The Weev agent · Upcoming

And for the estate that predates all of this — the SQL Server Agent chains, the Task Scheduler entries, the vendor tools — the answer is wrap, don't migrate: the incumbent keeps executing while Weev keeps the clock and the record, until each job is ready to move. Evidence an examiner accepts, from day one, without a rewrite anywhere in sight.

03 · One Tuesday night

One Tuesday night, twice

The difference every alternative misses, on an actual Tuesday. Same jobs, same code, same clock — one dependency in a comment, one declared.

As it happened · dependency in a comment

02:14nightly_settlement fired on schedule
02:14# was ledger_close actually done? the crontab can’t say
02:31grepping cron logs on payments-01, payments-02
02:58found it: fx_rates ran 40 min long — settlement used stale rates
03:40manual re-run, runbook §4, two engineers on the call
09:00auditor asks why the regulatory export was late

The job ran fine. It ran before its input existed, because "after ledger_close" was written in a comment instead of enforced by anything.

With the edge declared · same night

02:14settlement not started · fx_rates still running
02:52fx_rates cleared · deps satisfied (2/2)
02:52nightly_settlement triggered by graph
03:39settlement cleared · regulatory_export released
09:00export on time · run record answers the auditor

Nobody was woken up.

The only difference between these two columns is that one dependency became something the platform could enforce.

04 · The fit

Built for the jobs nobody wants to migrate

And honest about what it isn't for.

Good fit

Nightly settlement, billing and ledger runs on a fixed clock
Regulatory exports with a hard deadline and an auditor who asks
Job chains held together by cron, retries and Slack alerts
An estate of SQL Server Agent and Task Scheduler jobs an examiner asks about

Not a fit

One-off scripts and ad-hoc automation
App-to-app automation you'd click together in a no-code builder
Work you'd happily rebuild inside a durable-execution runtime
Streaming and event-at-a-time pipelines

05 · The deepening layer

Orchestration moves to the people who write the jobs

What SDK Mode buys you today, once a job is declared: the dependency becomes code the author owns.

The scheduler world

Developers write the job and ops owns when and why it runs. Every dependency change is a ticket; the graph lives in a tool the author never opens.

author  → writes the job
ops     → owns the edge
ticket  → changes the edge

With Weev

The dependency is code, next to the job it belongs to. It goes through review like code, versions like code, rolls back like code. The control plane validates the graph before release — cycles, missing edges and duplicate jobs fail the push, not production. Ops still governs policy; they stop being the keepers of every edge.

author  → writes the job and the edge
review  → approves both
ops     → governs policy

Declared where it's written. Validated before it ships. Accounted for when it runs.

Govern the jobs you already run.

Start with one job. No credit card required.