Preview · agent deploys

Approve an agent's deploy once. It runs again only while the ticket holds.

A person approves a supported agent deploy against the company's change ticket. FieldHash reuses that approval while the deploy matches its reviewed inputs and the ticket conditions it relies on remain valid.

The company's records and authorized reviewers set what the agent may do. FieldHash checks that authority at the connected action as the work changes. Cancel a ticket or change a condition the approval relied on, and the affected approval returns to review, with a signed record of why.

PDF · 120 KB

A live run of Claude Code with the FieldHash plugin against a local FieldHash server, replayed from its transcript with the messages shortened and the timing compressed. kubectl is a stand-in, so nothing reached a cluster. The results at the end come from the scripted side-by-side tests below, which are separate from this run.

What happens in the video
  1. Two change tickets are approved: CHG-412 for the web deploy, CHG-418 for the worker.
  2. The agent runs both deploys. Each goes to a person first, and neither runs.
  3. A reviewer approves each one, naming the ticket it relies on.
  4. The agent runs the same deploys again. Both approvals are reused.
  5. CHG-412 moves to in progress. Nothing the approval relies on changed, so the next re-apply runs.
  6. The agent edits the web manifest. That is a different deploy, so it goes to a person.
  7. The agent puts the manifest back exactly as approved. The original approval applies again.
  8. The change manager cancels CHG-412. The web deploy goes back to a person; the worker deploy keeps running.
  9. Every decision has a signed receipt that verifies offline.
  10. The side-by-side results: right answers out of 190 for each approach, and the custom check code each one needed.

What this preview covers

This page demonstrates supported kubectl apply calls through the FieldHash hook. Approval reuse binds selected deploy inputs, not the complete cluster effect. Enforcement depends on the agent tool running the hook for every covered call. Change-bound approvals are built and tested, off by default, and not yet released.

Evaluation

Evaluate one workflow in six weeks.

Evaluate your agents' deploy approvals against the controls you already have. FieldHash runs on your systems, in shadow mode, with one workflow and acceptance criteria agreed upfront. It records what it would have done. Production enforcement stays off.

Week one: scope and setup.

Together we agree the covered execution paths, change-ticket source, reuse conditions and acceptance criteria. We then set up the agreed connection in your environment.

Weeks two to five: observe in shadow.

FieldHash records which approvals it would reuse and which deploys it would return to a person. We compare false allows, extra reviews and review burden with your existing controls, alongside latency and operating effort.

Week six: review the results.

Your team reviews the measured results and signed decision records. The closeout supports a decision to adjust, continue in shadow, stop, or proceed toward separately accepted production enforcement.

The readout measures whether valid review can be reused, where current authority changes the decision, and what the control costs to operate. Your team can check the signed decision records offline. Production enforcement requires separate acceptance of the integration, failure behavior and rollback.

Scope a six-week evaluation

Side by side

Ticket-bound approvals, without a custom approval check.

We tested 214 situations: tickets cancelled, closed, reassigned or rescheduled; manifests edited and put back; commands reordered, respelled or pointed somewhere new. After the first-round fix, we specified the second round's case-generation rules and scoring criteria before running it. The tests were scripted hook tests, separate from the live run above, with FieldHash next to what a platform team could set up or build instead.

FieldHash

190/190

right answers

No custom approval-checking code was added. The approval itself records which ticket it relies on.

Separately implemented ticket check

190/190

right answers

1,200 lines of custom checking code in this implementation, plus its own approvals store, written from a plain spec by a separate AI agent.

Tested configuration: FieldHash with window enforcement on, in a preview build that is off by default and not yet released. On default settings, with window enforcement off, it scored 165/190: it missed the 5 cases where a change window simply ended and made 20 extra asks. No custom approval-checking code was added for FieldHash; change-system integration and operating effort are excluded for every approach.

Right answers out of 190 scored situations, by approach
ApproachRight answersWould proceed without needed reviewExtra asksCustom check code
FieldHashwindow enforcement on, preview build190/19000none added
Separately implemented ticket checkwritten from a plain spec by a separate AI agent190/190001,200 lines
Quick ticket checkminimal, our own179/190011111 lines
Expiring approval (modeled)exact command, 8 hours129/1905011config
Standing allow rule (modeled)every kubectl apply102/1908801 rule

How we got here. The first round used 14 hand-picked situations, and FieldHash got 13: when a ticket's change window was extended, it asked a person it didn't need to. We fixed that the same day, wrote down a second round before running it, the original 14 plus 200 generated from a fixed seed, and the fixed FieldHash got every scored situation right.

When it's a judgment call, such as a ticket cancelled and reopened, or an approver changed and changed back, FieldHash asks a person every time: if a ticket condition the approval relied on changed since the yes, even if it changed back, a person sees it. Restoring the exact approved manifest is different: that is the same deploy, so the approval applies again. We report those 24 situations separately, without scoring; the separately implemented check let half of them run.

How we tested

Written down first, then run.

  • Scripted hook tests: each situation set up the approvals, applied its changes, then sent one deploy call to the real FieldHash hook and server, or to a comparison check. No agent was involved; the live run above is separate.
  • 214 situations: 14 written by hand and 200 generated from a fixed seed. 24 judgment calls are reported separately, without scoring, so 190 are scored.
  • Each round's right answers were written down before it ran; after the first-round fix, the second round's case-generation rules and scoring criteria were specified before running it. The approaches with recorded predictions matched them. No prediction was made for the separately implemented ticket check.
  • The expiring approval and the standing allow rule are modeled from their rules; the other approaches ran.
  • Not covered: connecting a real change system, operating effort, or a real cluster. kubectl was a stand-in, and a file stood in for the change system.

What it gives a team

One review counts for more than one deploy.

The approval is the binding.

The reviewer names the ticket when they say yes. There is no approvals file or mapping table to write and keep.

Approval tied to supported deploy inputs.

An edited manifest, another cluster context or another namespace goes back to a person. Supported flags in another order still identify the same deploy.

Only the affected approval goes back.

Cancel one ticket and the deploys that relied on it return to a person. Unrelated approvals remain eligible for reuse.

Evidence an auditor can check.

Every decision carries a signed receipt that verifies offline, with no ticket ids, file names or cluster names in it.

Contact

Have agents touching production? Let's talk.

Tell me about the workflow, and I'll tell you honestly whether it's a good first fit.

Aaron Martinez · Founder · aaron@fieldhash.ai

A preview: change-bound approvals are built and tested, off by default, and not yet released. Whether they reduce a real team's implementation and operating effort is what an evaluation would measure.