THE TASTE ENGINE

The hard problem of autonomous systems isn't capability — it's alignment to one specific person's judgment, at the task level, without that person in the loop.

A dispatcher that ranks work by keyword frequency is fast and deterministic. It is also confidently wrong in ways that erode trust. It will surface a low-signal formatting task above a revenue-critical integration because the formatting task matched more trigger words. It will treat all work as equivalent because it has no model of what the principal actually values. Over time, an autonomous system with no taste doesn't just do the wrong things — it does the wrong things with exactly the same confidence it does the right ones.

The studio needed a system that could distinguish between “works as described” and “what would actually be picked here” — and could do it consistently, across every autonomous dispatch, without requiring a human veto on every item.

The Taste Engine is a veto filter and weight system wired into the autonomous dispatch pipeline. Every candidate task passes through it before it can be queued for execution. The engine embodies the principal's judgment in two layers:

Hard vetoes. Five absolute rules, distilled from the system's operating principles. A task that trips a veto is dropped entirely, never queued. These don't have weights; they have no exceptions. The principal's explicit override always wins, but no autonomous path can bypass a veto.

Weighted principles. 12 principles, each carrying a score in the range [0.2, 1.0], distilled from 60+ recorded feedback moments and graded work history. The engine scores every candidate task against the active weights and ranks accordingly. High-weight principles like “revenue impact” and “infra leverage” pull tasks up. Low-weight signals like “novelty for its own sake” pull tasks down.

The weights are machine-readable. The whole canon — vetoes and principles — is mirrored to a single source of truth that every dispatch-capable agent loads before making a pick.

Day-one catch. The engine was wired into dispatch and immediately caught 3 mis-ranked tasks that a keyword ranker had placed at the front of the queue. All three were technically valid work items. None of them were what the principal would have picked. The filter vetoed them before they reached execution. That was day one — not after weeks of calibration, not after a tuning sprint. The catch happened because the vetoes were encoding real judgment, not rules-of-thumb.

The grading loop. Every autonomous pick emits an append-only decision receipt: what was chosen, why (which principles scored it up), and what was displaced. When the principal grades a receipt — good or bad — the system applies a ±0.05 weight nudge to the principles that drove the pick. The nudge is clamped to [0.2, 1.0] on both ends. No principle can drift to zero (the system always considers it) and no principle can hit 1.0 (no single axis dominates). The learning rate is intentionally slow: one bad grade shifts the system by 5%, not 50%.

Grades are final. The grading record is append-only. A correction adds a new entry; it never rewrites the old one. This is a deliberate design property: the principal can see exactly what the system learned, when, and why. There is no silent revision history. If a grade turns out to be wrong, the next grade corrects it forward — the old grade stays in the log as evidence of how the system got to where it is.

Calibration golden set. 32 verbatim accept/bounce verdicts across 6 domains, each tagged with the principles that explain the verdict. This is the engine's ground truth — not a training set in the ML sense, but a reference set the system can be tested against. When a weight update shifts behavior, the golden set is the check on whether the shift was in the right direction.

Fail-open design. A taste-engine outage never blocks work. If the engine is unavailable, dispatch degrades to a plainer ranking — which is worse but not broken. The engine is a quality gate, not a chokepoint. This was a deliberate choice: making the filter a hard dependency would trade a taste problem for an availability problem, which is a worse trade.

The engine sits at the front of the autonomous dispatch pipeline as a filter, not a ranker. The upstream queue presents candidates; the engine vetoes any that break a hard rule, scores the survivors against weighted principles, and returns a ranked list. Dispatch picks from the top.

Forced picks bypass the filter entirely. When the principal explicitly names a task, the engine steps aside: the principal's direct choice always wins over any weighted ranking. The engine influences unattended dispatch — it has no authority over deliberate human direction.

The same judgment system drives the taste layer in the PersonaOS project, where alignment to one person's aesthetic and decision style is similarly the hard problem. The canonization pattern — recorded verdicts becoming machine-readable weights — is shared across both.

The engine is live as the dispatch veto filter. The 5 vetoes and 12 weighted principles are in production, distilled from 60+ recorded feedback moments. The calibration golden set covers 32 verbatim accept/bounce verdicts across 6 domains.

Day-one impact: 3 mis-ranked tasks caught and blocked before execution. The system is tracking agreement-rate trend daily — this is early data and the long-run trend is UNMEASURED. What's measured is that the filter has been running without blocking any work due to an outage (fail-open held) and without triggering a revert.

The grading loop has produced its first weight nudges. Grades are final; the correction log is append-only. The principal can audit exactly what the system learned and from which specific receipt — there is no implicit history being silently revised.

The question the engine is designed to answer over time — does the system's autonomous taste converge toward the principal's actual judgment? — is an honest open question. The grading loop exists to produce that answer. The evidence so far is promising but early. That's the accurate thing to say.