What CrowdRelay Autopilot delivers today

Two months ago I wrote that the Autopilot makes boring decisions in deterministic Rust. That post covered the deciding layer. What it left out is that a decision which can't reach anybody is just an opinion with extra steps.

Since then I've built the other half: the unglamorous machinery that turns safe decisions into delivered work, measured results and a quiet operator brief. This is a summary of what the system actually delivers today, because "automation" means little until you can point at the tasks that stopped needing you.

Asking for work#

The first production lesson arrived right after the authority gates opened: every execution path starved. The executor could send pitches, but the pitch tables held zero rows, and nothing in the system noticed that this was a problem.

So the agent learned to ask. An outreach-supply context notices when there are fewer confirmed submission routes than the policy floor and emits a discovery request. The adapter sweeps published sources, screens each candidate on write against explicit refusal reasons, and reports the batch even when it's empty. An empty batch after reading two hundred playlist descriptions is an answer: the source is dry. No report at all means something else, a broken credential. Those need different fixes, so they get different answers.

The same shape now exists for scene partners. A city with activated fans but no local beacons triggers a scout. A verified beacon inside its own city's invite window gets asked to carry invite codes for the show. Our system issues those codes, so every signup that comes back is attributed and consented by construction.

Pitch waves with evidence#

Free-reach pitching runs in waves: a ranked batch of pitches for one release or one tour leg, assembled from facts the system already owns, such as metric movement with timestamps, actual attendance figures and existing coverage. Every number carries the moment it was read. If the system can't read a figure, the field says so instead of showing a zero, because a zero it made up reads exactly like a zero it measured.

A wave is sized to the lower of two numbers: what the operator capped per wave, and what's left of the weekly contact budget. Sized above that, forty approved pitches would go out six at a time and nobody would understand why. Approval is one statement over the whole batch, because approving forty rows individually is how a human stops approving anything.

Verifying placements#

A curator says yes. In most tooling that's where tracking ends and hope begins.

Here a claimed placement counts toward nothing until a public read confirms the track is in the playlist. A claim that never gets confirmed settles as ghosted. That isn't an accusation (it may be a typo or a private list), but it isn't measurable either. Confirmed placements are re-checked on a schedule, because add-for-a-screenshot is a known business model. A track removed inside the verification window records as withdrawn, which is the strongest scam signal there is. It suppresses the operator behind it, not just one playlist, and their other lists get rescreened.

Ramping up sending#

Deliverability got the same treatment. A workspace that has never sent starts at three third-party touches a week, regardless of what the budget allows. A standing start looks to a receiving provider like exactly what it is. The ceiling widens weekly as the record earns it, and never past the operator's own budget, which is a ceiling and not a target.

Bounces and spam complaints are ingested from the sending provider, deduplicated on the provider's own reference so a retried webhook isn't counted twice, and turned into rates over a rolling window. If they cross the thresholds, the sending ceiling closes to zero before the next wave instead of showing up in a digest afterwards. A hard bounce finishes the address through the existing suppression. Soft bounces suppress nobody, because a full mailbox is ordinary.

There's also a smaller rule I care about: faults dated outside the window they feed are refused, not clamped. A silently moved timestamp produces a number nobody can argue with later.

Booking negotiation with a floor#

Booking opportunities now carry a computed cost (fuel, tolls, rooms, per diems, and a vehicle count derived from crew and backline rather than assumed) plus a walk-away fee built from it. The negotiation ladder freezes when the negotiation opens, so last week's counter stays explainable. Acceptance re-checks current costs at execution time, because hours pass between drafting and approving.

Some things are refusals in the domain rather than settings: a required contract, exclusivity, a date past the annual stretch, a gig whose cost can't be computed. A festival slot worth playing at break-even escalates to a human with the reason attached instead of dying in a budget rule.

The Spotify editorial pitch is one form per release, with no API, submitted by a human. The system detects the deadline, assembles text and evidence, parks it and chases it, and both events it emits state plainly that the agent didn't submit anything. An automation claiming credit for that form would be worse than no automation.

Three postures instead of twenty-six settings#

The authority model behind all this used to mean twenty-six separate settings. Now there are three named postures (grounded, working, full send), applied atomically: every context level, all four class ceilings and the envelope switches change in one transaction with one ledger entry.

Grounded rehearses and executes nothing. Working lets first-party work run alone and drafts outward contact for one-click approval. Full send lets owned-audience sends and free pitching run unattended inside budget, cooldown and deliverability limits. Money stays behind approval in every posture, pinned by a test. Budgets survive a posture flip on purpose: you can tune the numbers whenever you want, and the dial only moves authority.

Individual knobs are editable too: screening floors, lead windows, cooldowns per context. They're validated against the same typed config the reader parses, so an unknown key is refused instead of stored and ignored.

Labelled reporting#

Every measured number says what kind of number it is. Smart-link clicks are attribution. Follower movement after a campaign is correlational, stated with its window. Where evidence is too thin to answer, the response says insufficient instead of rounding up.

The daily brief is silent by default. It speaks up for parked work, approvals waiting past their horizon and a halted sending ceiling, the cases where silence would mislead. Everything else waits for somebody to look.

What stays manual#

• Posting into Facebook groups and Discords: platform rules make that a human act.
• The Spotify editorial form: no API exists.
• Anything paid: refused at every autonomy level, not configured away.

What's left between built and running is deployment: activating workflows, running the first discovery sweep, connecting feeds, then letting the working posture earn full send on evidence rather than optimism.

That matches the original definition. The system collects the facts, makes the routine decisions, executes within explicit limits, labels what it measures and comes back only when it needs us. The difference now is that "executes" covers the actual work: finding targets, drafting pitches with evidence, verifying placements, protecting the sender reputation and asking for more supply when the pipeline is empty.