Deterministic execution without the drama

I want AI to be useful, not surprising. Surprises are expensive when real work is on the line. That only happens when execution is predictable.

The problem

LLMs are probabilistic. That is fine for brainstorming, but it is risky for real work. The moment a system can change state, the tolerance for uncertainty drops to near zero.

The principle

We treat execution as a contract. The system can propose, but a human commits. The plan should be explicit, validated, and explainable before anything changes.

The approach

Senza turns intent into a structured plan, checks it, then waits for approval. The goal is not to slow things down. It is to move fast without guessing.

At a high level, the flow looks like this:

const plan = await senza.compile({
  intent: "Reschedule the sprint retro to Thursday",
  context: { team: "Product", timebox: "this-week" }
});

const validation = await senza.validate(plan);
if (!validation.ok) {
  throw new Error(validation.reason);
}

const commit = await senza.requestCommit(plan, {
  requestedBy: "sean",
  reason: "Team conflict on Wednesday"
});

if (!commit.approved) {
  return { status: "cancelled" };
}

await senza.execute(plan);

The key idea is separation. Generation is not execution. Validation happens before anything changes. Human approval is the gate.

This is the pattern we want around any action that touches shared reality, like schedules, tasks, or decisions.

Why this matters

This design keeps people in control without killing speed. It also creates a clear record of what happened and why, which is as important as the outcome itself.

If you want the deeper view, read The backbone of reliable AI: deterministic ops.