← Back to Guides

Companion to the book Harness Engineering for Production AI Systems · this part maps to Book Ch 9

GuideFor: AI Engineers, ML Engineers, Platform Engineers, AI Systems Architects

AI Agent Approval Gates: Failed Checks Must Never Widen

Send every failed guardrail check to a human, and in a mode with no reviewer the suspicious refund becomes one somebody may approve while its clean twin is refused.

#harness-engineering#human-in-the-loop#approval-gates#llm-agents#ai-safety#production-ai-systems

At 02:14 the billing agent was draining the overnight queue. It proposed a refund of 940.00 to account acct_4417, and the comparator that checks amounts against invoices failed it: no invoice for that account carries 940.00. What is actually wrong on invoice inv_9107 is a single sign-on (SSO) add-on of 120.00 charged twice, so the customer is owed 120.00.

So the approval gate escalated, which is what it was written to do when an AI agent's guardrail check fails. The run ended with the ticket marked as awaiting approval and the 940.00 proposal attached, ready for a reviewer to approve as shown in the morning.

Ten minutes later a different ticket produced a clean refund of 900.00 that passed every check, and the gate refused it, because overnight the policy has no review band for refunds, so anything from 50.00 up has no path while nobody is at the console. Nobody overnight may approve 900.00, yet the gate had just queued 940.00 for approval, and all the 940.00 had done to earn that was fail a check.

I constructed this night from the billing support agent this series is built around, but the gate is real: it is the policy gate from Chapter 9 of my book. I extracted the companion code at the chapter's tag and ran its own PolicyGate on these two proposals to get the decisions above.

The claim this article defends: a gate cannot know whether an action is correct, so it decides who may be wrong about it. Each mode's amount band records who may decide at each amount, and that band is the ceiling on every path a proposal can take. A failed check may narrow the path. It must never widen it. "When a check fails, escalate to a human" is what Arcjet's sample approval-gate code does with a deny, and what my own book's gate does with a failed check.

That rule widens the path whenever the clean proposal would have been refused.

One rule makes "ceiling" precise: an approval is bounded by the band of the mode in which the gate decided. A morning reviewer who approves the 02:14 proposal is approving a queue-drain decision, and queue-drain gives refunds no review band. If that reviewer wants to act under copilot's band, they re-propose under copilot's gate. So the overnight harm is specific: the check-first gate offers "approve as shown" on bytes that failed a check, under a band that allows no approval at all.

The plainest case needs no overnight queue. In copilot, with a person at the console, the book's gate refuses a clean refund of 5,000.00, because copilot's review band ends at 2,000.00. Make the same refund fail its invoice check and the gate escalates it, so a reviewer may now approve a 5,000.00 refund that is on no invoice. That breaks the chapter's own rule: "If the answer would be no whoever you asked, refuse".

d2
grid-rows: 1
grid-gap: 40
failed: "Failed: 940.00" {
  label.near: top-center
  style: {fill: "#FDECEA"; stroke: "#C0392B"; font-color: "#2C2C2A"}
  p1: "issue_refund 940.00\non no invoice" {style: {fill: "#4A90E2"; stroke: "#2C6FB0"; font-color: "#FFFFFF"}}
  g1: "gate: check failed\nso escalate" {style: {fill: "#7B68EE"; stroke: "#5A4BC4"; font-color: "#FFFFFF"}}
  o1: "awaiting approval\nreviewer may say yes" {style: {fill: "#FFD93D"; stroke: "#C9A800"; font-color: "#2C2C2A"}}
  p1 -> g1 -> o1
}
clean: "Clean: 900.00" {
  label.near: top-center
  style: {fill: "#EAF7EE"; stroke: "#3F9E52"; font-color: "#2C2C2A"}
  p2: "issue_refund 900.00\non an invoice" {style: {fill: "#4A90E2"; stroke: "#2C6FB0"; font-color: "#FFFFFF"}}
  g2: "gate: amount band\nhas no review" {style: {fill: "#7B68EE"; stroke: "#5A4BC4"; font-color: "#FFFFFF"}}
  o2: "refused\nnobody may say yes" {style: {fill: "#E74C3C"; stroke: "#A93226"; font-color: "#FFFFFF"}}
  p2 -> g2 -> o2
}

The two runs differ in one input: the comparator's verdict. Yet the column with the worse input ends at the outcome with more authority. That inversion is what this part is about. Everything else in Chapter 9 is left to the book.

Consequence Gating: human-in-the-loop gates decide who may be wrong

Part 1 of this series put one fact under everything else: this domain has no oracle. Nobody in the system knows whether 940.00 is right. A comparator can find that the amount is on no invoice, and that finding is evidence, but a customer can still be owed money an invoice does not show.

My book's name for the response is Consequence Gating: "A gate does not decide whether an action is correct, because nobody in the system can. It decides whether the system is allowed to be wrong about it: what being wrong would cost, and who is available to carry it."

"Gate on consequence" as a phrase is not new, and I am not presenting it as mine. Arcjet's guide to approval gates says "Gate on consequence, not on model confidence." An anonymously listed preprint on Zenodo reports that "consequence gating takes attack success on the irreversible/catastrophic class from 33.8% (134/397) to 0.0% (0/397) under abort-mode replay". The preprint reports those figures itself, and they are not independently reproduced. In April I wrote up Consequence-Proportional Gating on this blog, where scrutiny scales with the severity of what could go wrong.

All three key on the action (how irreversible it is, how large, how far it reaches), while who is available to carry being wrong is a second input that none of them carries. With it, one refund can be allowed at 14:00 and refused at 02:14. Here is the book's refund policy for the two modes the billing agent runs in.

d2
grid-rows: 3
grid-columns: 5
grid-gap: 6
h0: "issue_refund" {style: {fill: "#95A5A6"; stroke: "#6B7B7C"; font-color: "#FFFFFF"; bold: true}}
h1: "under 50" {style: {fill: "#95A5A6"; stroke: "#6B7B7C"; font-color: "#FFFFFF"}}
h2: "50 to 200" {style: {fill: "#95A5A6"; stroke: "#6B7B7C"; font-color: "#FFFFFF"}}
h3: "200 to 2,000" {style: {fill: "#95A5A6"; stroke: "#6B7B7C"; font-color: "#FFFFFF"}}
h4: "2,000 and above" {style: {fill: "#95A5A6"; stroke: "#6B7B7C"; font-color: "#FFFFFF"}}
c0: "copilot\n(a person present)" {style: {fill: "#4A90E2"; stroke: "#2C6FB0"; font-color: "#FFFFFF"}}
c1: "AUTO\ncode decides" {style: {fill: "#6BCF7F"; stroke: "#3F9E52"; font-color: "#2C2C2A"}}
c2: "AUTO\ncode decides" {style: {fill: "#6BCF7F"; stroke: "#3F9E52"; font-color: "#2C2C2A"}}
c3: "REVIEW\na person decides" {style: {fill: "#FFD93D"; stroke: "#C9A800"; font-color: "#2C2C2A"}}
c4: "NEVER\nno path" {style: {fill: "#E74C3C"; stroke: "#A93226"; font-color: "#FFFFFF"}}
q0: "queue-drain\n(nobody present)" {style: {fill: "#4A90E2"; stroke: "#2C6FB0"; font-color: "#FFFFFF"}}
q1: "AUTO\ncode decides" {style: {fill: "#6BCF7F"; stroke: "#3F9E52"; font-color: "#2C2C2A"}}
q2: "NEVER\nno path" {style: {fill: "#E74C3C"; stroke: "#A93226"; font-color: "#FFFFFF"}}
q3: "NEVER\nno path" {style: {fill: "#E74C3C"; stroke: "#A93226"; font-color: "#FFFFFF"}}
q4: "NEVER\nno path" {style: {fill: "#E74C3C"; stroke: "#A93226"; font-color: "#FFFFFF"}}

The bottom row has no yellow cell. That is deliberate, and it is what risk-keyed designs miss. Overnight, an irreversible refund gets no review at all, because for an irreversible tool a review band is a claim that a person is there now and is the one deciding. NEVER means nobody in this configuration has agreed to carry this, so it does not happen.

Whether a mode with nobody present may still have a review band depends on the tool. At the chapter's tag the policy file gives apply_credit a queue-drain review band of 100.00 to 1,000.00. A credit approved in error can be reversed by a counter-entry, so it can wait for a morning reviewer. A refund approved in error cannot be reversed.

The June post on the Checkpoint Membrane already covers what happens after a review opens: expiry, the default when nobody answers, and the rubber-stamp threshold past which approval stops being oversight. None of that is re-argued here, because this part sits one step earlier and asks which proposals may open a review at all.

These per-mode amount bands are also not the Authority Band of the Operational Authority Gradient, which a run earns through the reversibility and blast radius of everything it may do. Part 14 builds that. An amount band is narrower. It is one rule's answer to who may decide about one tool at one amount.

When a failed guardrail check escalates to a human

Here is the gate the 02:14 night ran, reduced to what decides. It keeps the book's ordering at the chapter tag: the gate reads required verdicts first, and a failed one escalates before the gate looks at the amount. It also keeps the book's rule that a thresholded tool with no amount is not automatic. The tag's refund rule also requires a structured_output verdict, which I dropped here because it passes in every case shown. The tag's Decision also has no allowed field. I added one, filled in from what the chapter says an escalated proposal waits for: an approval of exactly what was shown, or an edit. Like the book's, neither gate checks that an amount is positive. Both rely on Part 7's output checks upstream, which flag a non-numeric amount as a shape error and a non-positive or non-finite one as a content error, before it reaches the band. Whether the model should supply the amount at all is a separate question, and Part 10 narrows the tool signature so the model never supplies the amount.

python
from dataclasses import dataclassfrom decimal import Decimalfrom enum import Enumclass Mode(str, Enum):    COPILOT = "copilot"          # a person is at the console    QUEUE_DRAIN = "queue-drain"  # overnight, nobody isclass Disposition(str, Enum):    ALLOW = "allow"        # code acts now    ESCALATE = "escalate"  # a person decides; Decision.allowed says how    REFUSE = "refuse"      # nobody in this mode may approve itclass Tier(str, Enum):    AUTO = "auto"    REVIEW = "review"    NEVER = "never"@dataclass(frozen=True)class Verdict:    name: str    passed: bool    detail: str = ""@dataclass(frozen=True)class Rule:    tool: str    mode: Mode    requires: tuple[str, ...]    auto_below: Decimal    review_below: Decimal | None  # None: this mode has no review band    def tier_for(self, amount: Decimal | None) -> Tier:        if amount is None:            return Tier.REVIEW  # the book: no amount is not automatic        if amount < self.auto_below:            return Tier.AUTO        if self.review_below is not None and amount < self.review_below:            return Tier.REVIEW        return Tier.NEVERPOLICY = {    (r.tool, r.mode): r    for r in (        Rule("issue_refund", Mode.COPILOT, ("amount_on_invoice",),             Decimal("200.00"), Decimal("2000.00")),        Rule("issue_refund", Mode.QUEUE_DRAIN, ("amount_on_invoice",),             Decimal("50.00"), None),    )}APPROVE_EDIT_REJECT = frozenset({"approve", "edit", "reject"})EDIT_REJECT = frozenset({"edit", "reject"})  # approving would clear a failed verdict@dataclass(frozen=True)class Decision:    disposition: Disposition    reason: str    hand_off: str | None = None  # note for the ticket, never a proposal    allowed: frozenset[str] = frozenset()  # what a reviewer may do, if escalateddef decide_check_first(tool, mode, amount, verdicts):    """Chapter 9's ordering, and deny-as-hold glue: a failed check goes to a person."""    rule = POLICY.get((tool, mode))    if rule is None:        return Decision(Disposition.REFUSE, f"no rule for {tool} in {mode.value}")    for name in rule.requires:        v = verdicts.get(name)        if v is None:            return Decision(Disposition.REFUSE, f"{name} required, not emitted")        if not v.passed:            return Decision(Disposition.ESCALATE, f"{name}: {v.detail}",                            allowed=APPROVE_EDIT_REJECT)    tier = rule.tier_for(amount)    if tier is Tier.AUTO:        return Decision(Disposition.ALLOW, "within the automatic band")    if tier is Tier.REVIEW:        if mode is Mode.QUEUE_DRAIN:            return Decision(Disposition.ESCALATE,                            f"{tool} needs review and nobody is present",                            allowed=APPROVE_EDIT_REJECT)        return Decision(Disposition.ESCALATE, f"{tool} needs review",                        allowed=APPROVE_EDIT_REJECT)    return Decision(Disposition.REFUSE, f"no path in {mode.value}")

Most of this is right, and the fix keeps those parts. There are three dispositions, not a boolean. A missing rule refuses instead of defaulting to allow, and a verdict that nobody emitted refuses instead of being read as "no problem found". Under Part 3's Role Test this component is a gate, and it earns the name: it can make the action fail by itself, every time it decides to.

One ordering choice is the defect. Because the if not v.passed branch returns before rule.tier_for(amount) runs, the band never sees a proposal whose check failed, and that proposal gets the widest outcome a person can give.

d2
direction: down
p: "proposal: tool, amount" {style: {fill: "#4A90E2"; stroke: "#2C6FB0"; font-color: "#FFFFFF"}}
r: "1. rule for tool\nin this mode?" {style: {fill: "#7B68EE"; stroke: "#5A4BC4"; font-color: "#FFFFFF"}}
v: "2. required verdicts\npassed?" {style: {fill: "#7B68EE"; stroke: "#5A4BC4"; font-color: "#FFFFFF"}}
b: "3. amount band\nAUTO / REVIEW / NEVER" {style: {fill: "#7B68EE"; stroke: "#5A4BC4"; font-color: "#FFFFFF"}}
esc: "ESCALATE\nband never read" {style: {fill: "#FFD93D"; stroke: "#C9A800"; font-color: "#2C2C2A"}}
out: "ALLOW / ESCALATE / REFUSE\nas the band says" {style: {fill: "#6BCF7F"; stroke: "#3F9E52"; font-color: "#2C2C2A"}}
ref: "REFUSE" {style: {fill: "#E74C3C"; stroke: "#A93226"; font-color: "#FFFFFF"}}
p -> r
r -> ref: "no rule"
r -> v: "yes"
v -> esc: "a check failed"
v -> ref: "not emitted"
v -> b: "all passed"
b -> out

Only the yellow box leaves step 2, skips step 3, and still hands a person something to approve. A verdict nobody emitted also leaves step 2, but as a refusal, which is safe. Whatever its amount and whatever mode the run is in, every proposal that reaches the yellow box gets the same outcome.

This driver runs the night's proposals through both gates and prints both tables in this article. Run it once you have defined the band-first decide further down:

python
PASS = {"amount_on_invoice": Verdict("amount_on_invoice", True)}FAIL = {"amount_on_invoice": Verdict(    "amount_on_invoice", False, "on no invoice")}cases = [    ("900.00", Mode.QUEUE_DRAIN, PASS),    ("940.00", Mode.QUEUE_DRAIN, FAIL),    ("940.00", Mode.COPILOT, FAIL),    ("5000.00", Mode.COPILOT, PASS),    ("5000.00", Mode.COPILOT, FAIL),    (None, Mode.QUEUE_DRAIN, PASS),]for name, gate in (("check-first", decide_check_first), ("band-first", decide)):    print(f"--- {name}")    for amt, mode, verdicts in cases:        amount = None if amt is None else Decimal(amt)        d = gate("issue_refund", mode, amount, verdicts)        tag = "failed" if verdicts is FAIL else "passed"        print(f"{str(amt):>8} {mode.value:<12} {tag:<7} "              f"{d.disposition.value:<9} {d.reason}")        if d.allowed:            print(f"{'':>30}reviewer may: {', '.join(sorted(d.allowed))}")        if d.hand_off:            print(f"{'':>30}hand-off: {d.hand_off}")

On the check-first gate it prints:

text
--- check-first  900.00 queue-drain  passed  refuse    no path in queue-drain  940.00 queue-drain  failed  escalate  amount_on_invoice: on no invoice                              reviewer may: approve, edit, reject  940.00 copilot      failed  escalate  amount_on_invoice: on no invoice                              reviewer may: approve, edit, reject 5000.00 copilot      passed  refuse    no path in copilot 5000.00 copilot      failed  escalate  amount_on_invoice: on no invoice                              reviewer may: approve, edit, reject    None queue-drain  passed  escalate  issue_refund needs review and nobody is present                              reviewer may: approve, edit, reject

Look at the two 5,000.00 lines. In copilot a person is present and the policy still says nobody may approve a refund of 5,000.00, yet if that refund fails its grounding check, a person may approve it. Of the two, only the refund on no invoice gets a signature line.

Who recommends escalating failed checks to a human

The rule "failed check, so a human" sounds like a principle, but its actual home is narrower than that, and the major agent frameworks do not do it by default. They make it easy to build, though. A LangChain when predicate that returns True when a verdict fails, or a Claude hook that returns ask, turns a failed check into a prompt in about three lines, which is why the audit in checklist item 8 covers predicates and hooks too.

LangChain's HumanInTheLoopMiddleware interrupts on the tools you configure, and its decisions are approve, edit, reject and respond. A tripped guardrail in the OpenAI Agents SDK raises: "The runner immediately raises an InputGuardrailTripwireTriggered or OutputGuardrailTripwireTriggered exception and halts agent execution." In the Claude Agent SDK, deny rules win over hooks and modes: "the call is denied this way even in bypassPermissions mode and when a hook returned allow."

Where the rule does live is in vendor approval-gate guidance, and in whatever code a team writes to follow it. Side by side:

d2
grid-rows: 1
grid-gap: 40
fw: "Framework defaults" {
  label.near: top-center
  style: {fill: "#EAF7EE"; stroke: "#3F9E52"; font-color: "#2C2C2A"}
  f1: "check fails" {style: {fill: "#4A90E2"; stroke: "#2C6FB0"; font-color: "#FFFFFF"}}
  f2: "raise, deny\nor reject" {style: {fill: "#E74C3C"; stroke: "#A93226"; font-color: "#FFFFFF"}}
  f1 -> f2
}
glue: "Vendor glue" {
  label.near: top-center
  style: {fill: "#FDECEA"; stroke: "#C0392B"; font-color: "#2C2C2A"}
  g1: "check fails" {style: {fill: "#4A90E2"; stroke: "#2C6FB0"; font-color: "#FFFFFF"}}
  g2: "hold for\nhuman review" {style: {fill: "#FFD93D"; stroke: "#C9A800"; font-color: "#2C2C2A"}}
  g3: "approved:\naction executes" {style: {fill: "#E74C3C"; stroke: "#A93226"; font-color: "#FFFFFF"}}
  g1 -> g2 -> g3
}

On the left the flow stops. On the right it takes one more step, and that step ends at the tool. Arcjet's approval-gate guide shows the right-hand column in code:

javascript
if (decision.conclusion === "DENY") {  // Do not execute. Persist the intent and hand it to a human.  return queueForHumanReview({...})}

Arcjet resolves that queue with "Approve, reject, or expire, plus the execution step that runs only on approval", so a denied action reaches execution through approval. In fairness, Arcjet frames this as a choice: "Your code can treat a deny, or an unconditional if, as a hold." Its sample deny comes from a rate limit, and it argues that "Expiring to rejection is the safe default." Even so, a denial becomes a hold, and a hold becomes an approvable path.

Layerup's agent documentation states the rule as policy, and the policy covers guardrail interventions too: every error condition "results in a deterministic, logged fallback action and human escalation." There the agent only recommends and an underwriter always decides, so its escalation probably grants no new authority, and I cite it for the rule only. My own April post drew a failed dry-run check as an arrow to "Flag + Human Review".

Amazon Web Services (AWS) dissents usefully in its Well-Architected Agentic AI Lens: "What reaches the human queue should be the genuinely ambiguous cases, with policy violations filtered automatically."

Verdict Widening: when a failed check opens a wider path

I call this failure Verdict Widening: a failed check moves a proposal onto a wider path than its twin would get, where the twin is the same proposal with the check passing.

Wider means more authority, and authority has a plain order here. ALLOW lets code act now. ESCALATE lets a named person decide, within the decisions the escalation allows. REFUSE lets nobody act on this proposal.

So a failed check that moves an automatic refund to a person's queue is narrowing. A human path has appeared, but code could act before and now only a person can. The test compares a proposal with itself. Fix the tool, the amount and the mode, flip one verdict from pass to fail, and compare the two dispositions on that order.

d2
direction: down
allow: "ALLOW\ncode acts now" {style: {fill: "#6BCF7F"; stroke: "#3F9E52"; font-color: "#2C2C2A"}}
esc: "ESCALATE\na person decides, within allowed" {style: {fill: "#FFD93D"; stroke: "#C9A800"; font-color: "#2C2C2A"}}
ref: "REFUSE\nnobody may approve this proposal" {style: {fill: "#E74C3C"; stroke: "#A93226"; font-color: "#FFFFFF"}}
allow -> esc: "failed check: permitted\n(narrows)" {style: {stroke: "#3F9E52"; stroke-width: 3}}
esc -> ref: "failed check: permitted\n(narrows)" {style: {stroke: "#3F9E52"; stroke-width: 3}}
ref -> esc: "Verdict Widening\n(never)" {style: {stroke: "#C0392B"; stroke-width: 3; stroke-dash: 4}}

Green arrows point down. A failed check that sends an automatic refund of 120.00 in copilot to a person is the comparator doing its job: if code may act at that amount, a person present may too. The red arrow points up. It stands for every upward move, including to ALLOW, and upward is the only direction the definition forbids. In the check-first gate every verdict widening starts in the same place: a proposal the band refused, made approvable by a verdict that said something was wrong with it.

Policy engines already solved half of this. The eXtensible Access Control Markup Language (XACML) has deny-overrides combining algorithms, and a deny-biased enforcement point treats anything other than an explicit permit as a denial. Access-control research also studied the property underneath this: how a decision should behave as the request changes. Tschantz and Krishnamurthi evaluated policy languages including XACML with properties that "examine the behavior of policies under enlarged requests". They studied how a policy's decision should behave as a request is enlarged, and I extend that intuition to worse evidence. XACML itself ranks Permit, Deny, NotApplicable and Indeterminate, and none of those values means "a person may approve".

ESCALATE is not a decision value in it, so no combining algorithm ever ranks an escalation against a refusal. Some agent frameworks already state a three-valued order. The Claude Agent SDK evaluates deny rules before ask rules and modes, and the OpenAI Agents SDK re-runs tool input guardrails after approval, so in both a deny outranks a pending approval. Vendor guidance that turns a deny into a hold leaves the hold's place in the order unstated, and Verdict Widening lives in that unstated place.

This part adds three things to that prior work. First, monotonicity checked per band: with ESCALATE between ALLOW and REFUSE, a gate's disposition must never gain authority when its evidence gets worse, inside every amount band of every mode, where the bands are keyed on who is present. Second, a test that needs no model: flip one verdict and compare the result with its twin. Third, a design rule that keeps "approve this proposal" separate from "hand this ticket to a person".

Verdict Widening is easy to confuse with three neighbours.

Fail-open means a check that cannot run leaves the action allowed. Here the check ran and returned a clear failure, and the result is "a person may now approve". That danger is quieter. A reviewer sees a proposal waiting in the queue, and a queue is a path to the tool.

Cedar comes closer. It is an open-source authorization policy language, and it documents "skip on error": any policy that errors is ignored, and that includes a forbid. Its designers wrote that "something that was intended to be forbidden may not be forbidden", called it "a debate with no winning side", and chose it on purpose for availability. So in Cedar an errored check widens the outcome by a documented choice.

The check-first gate widens on a check that worked. The chapter that ships it defends the order as deliberate: its test pins the escalation as intended, and no test compares a failed proposal with its passing twin.

A missing input breaks the same property through a gap that is not a verdict at all. Look at the last line of the output above: an issue_refund with no amount in queue-drain. tier_for returns REVIEW for a missing amount, as the book's does, so the gate escalates with "needs review and nobody is present" in a mode whose refund rule declares no review band. Its twin is the same refund at 50.00, the first amount queue-drain never allows, and the gate refuses it. Something about the proposal went wrong, and the proposal got more authority for it. The test below covers this case too, with the missing amount's twin set at that first never-allowed amount.

Band first: a check result may only narrow the approval path

Every refusal the check-first gate had survives the fix. Three things change, and all three only ever move the outcome toward refusal: the gate reads the band before the verdicts, a missing amount refuses before any verdict is read, and a failed check inside the band loses "approve".

python
def reviewable(rule: Rule, amount: Decimal) -> bool:    """Can a person in this mode approve this amount? Read from the band only."""    return rule.review_below is not None and amount < rule.review_belowdef decide(tool, mode, amount, verdicts):    """Band first. A failed verdict can only narrow what the band allows."""    rule = POLICY.get((tool, mode))    if rule is None:        return Decision(Disposition.REFUSE, f"no rule for {tool} in {mode.value}")    if amount is None:        # An approval approves the bytes shown. No amount, nothing to approve.        return Decision(Disposition.REFUSE, f"{tool} has no amount",                        hand_off="proposal arrived without an amount")    failed = []    for name in rule.requires:        v = verdicts.get(name)        if v is None:            return Decision(Disposition.REFUSE, f"{name} required, not emitted")        if not v.passed:            failed.append(f"{name}: {v.detail}")    if failed:        if reviewable(rule, amount):            # A person may decide, but approving as shown would clear a failed            # verdict. The reviewer edits (a new proposal) or rejects.            return Decision(Disposition.ESCALATE, "; ".join(failed),                            allowed=EDIT_REJECT)        return Decision(Disposition.REFUSE, f"no review path in {mode.value}",                        hand_off="; ".join(failed))    tier = rule.tier_for(amount)    if tier is Tier.AUTO:        return Decision(Disposition.ALLOW, "within the automatic band")    if tier is Tier.REVIEW:        return Decision(Disposition.ESCALATE, f"{tool} needs review",                        allowed=APPROVE_EDIT_REJECT)    return Decision(Disposition.REFUSE, f"no path in {mode.value}")

The change sits in the failed branch. reviewable asks only the band whether a person in this mode may decide at this amount, and a failed verdict escalates only when the answer is yes. Even then the escalation carries allowed=EDIT_REJECT: approving the proposal as shown would clear a failed verdict, so the reviewer may only correct it or reject it. A correction makes a new proposal with fresh verdicts. Keeping that in a field rather than in the reason text matters, because the code that executes an approval has to be able to refuse an approve it was never offered.

When the band has no review path, the gate refuses and puts the verdict's text in hand_off instead of dropping it. A missing amount refuses in every mode. My book's own rule for approvals is that "an approval approves exactly the proposal that was shown, byte for byte", and a refund with no amount gives the reviewer no amount to bind the approval to.

d2
direction: down
p: "proposal: tool, amount, mode" {style: {fill: "#4A90E2"; stroke: "#2C6FB0"; font-color: "#FFFFFF"}}
b: "1. band ceiling\nwho may decide at this amount, in this mode?" {style: {fill: "#7B68EE"; stroke: "#5A4BC4"; font-color: "#FFFFFF"}}
v: "2. verdicts\nmay only move the outcome down" {style: {fill: "#7B68EE"; stroke: "#5A4BC4"; font-color: "#FFFFFF"}}
a: "ALLOW\nband AUTO, all passed" {style: {fill: "#6BCF7F"; stroke: "#3F9E52"; font-color: "#2C2C2A"}}
e: "ESCALATE\nband has review here" {style: {fill: "#FFD93D"; stroke: "#C9A800"; font-color: "#2C2C2A"}}
r: "REFUSE\nhand-off note if a check failed\nor the amount is missing" {style: {fill: "#E74C3C"; stroke: "#A93226"; font-color: "#FFFFFF"}}
p -> b
b -> v
v -> a
v -> e
v -> r

Compare it with the check-first diagram: nothing now leaves the flow between the proposal and the band. Every proposal passes through step 1, so a failed verdict can only choose among outcomes the band already allows. Here are the same proposals.

text
--- band-first  900.00 queue-drain  passed  refuse    no path in queue-drain  940.00 queue-drain  failed  refuse    no review path in queue-drain                              hand-off: amount_on_invoice: on no invoice  940.00 copilot      failed  escalate  amount_on_invoice: on no invoice                              reviewer may: edit, reject 5000.00 copilot      passed  refuse    no path in copilot 5000.00 copilot      failed  refuse    no review path in copilot                              hand-off: amount_on_invoice: on no invoice    None queue-drain  passed  refuse    issue_refund has no amount                              hand-off: proposal arrived without an amount

Overnight, the 940.00 now refuses exactly as the clean 900.00 does, and the finding travels with the ticket. In copilot the 940.00 still escalates, because a person is present and 940.00 sits inside copilot's review band. That line matters. Outside the automatic band, the fix adds no refusal that the band does not call for, so a comparator that found something odd still sends it to a person wherever a person is allowed to decide. Two new refusals are deliberate: inside queue-drain's automatic band a failed check now refuses with a hand-off instead of queueing, and a missing amount refuses in every mode. And the 5,000.00 on no invoice refuses, just like the 5,000.00 that is on one.

This costs something, and the morning queue pays it. Overnight refusals rise, so the queue must show the hand-off note next to the ticket and make clear that nothing is waiting for a signature. Chapter 9 warns that "a harness whose only answer to novelty is no gets switched off within a quarter", and the warning holds. The answer here is a refusal plus a ticket: "no to this proposal, and here is what we found".

A harder cost follows from the same rule. Suppose the reviewer agrees the customer really is owed 940.00. Band first gives them no way to sign it: approving is not offered, and an edit that keeps 940.00 fails the invoice check again. The way through is the one Part 6 already gave: "To refund that amount, correct the invoice first." A reviewer can change the evidence the comparator reads, through the billing team that owns invoice corrections, but can never sign past it. That keeps the no-oracle premise honest, because the person who knows better has to put what they know into the system of record.

Test approval gates for Verdict Widening in CI

Because the definition only compares a gate with itself, you can test for Verdict Widening without a model. Pair every proposal on a grid with its twin. For each amount, mode and required check, the twin is the same proposal with the check passing. For each mode, also pair a proposal with no amount against the first amount the band never allows. That last pair is a rule more than a measurement: a request missing an input may get no more authority than the least-authorised value that input could take, and every rule here has a band that never allows, so the twin always refuses. Fail the build if any proposal gets more authority than its twin. A second assertion covers the half of the fix the twins cannot see, because they compare dispositions only: no decision whose required verdicts include a failure may offer "approve".

python
WIDTH = {Disposition.REFUSE: 0, Disposition.ESCALATE: 1, Disposition.ALLOW: 2}def worst_amount(rule: Rule) -> Decimal:    """The smallest amount in the NEVER band: the top edge the rule declares."""    return rule.review_below if rule.review_below is not None else rule.auto_belowdef widening_cases(gate, tool, amounts):    """Compare each proposal with its twin. Return (comparisons, cases that widen)."""    found, checked = [], 0    for mode in Mode:        rule = POLICY[(tool, mode)]        passed = {n: Verdict(n, True) for n in rule.requires}        pairs = []        for amount in amounts:            for check in rule.requires:                failed = {**passed, check: Verdict(check, False, "on no invoice")}                pairs.append((f"{amount} {check} failed", amount, failed, amount))        # A missing amount, compared with the first amount the band never allows.        pairs.append(("no amount", None, passed, worst_amount(rule)))        for label, amount, verdicts, twin in pairs:            bad = gate(tool, mode, amount, verdicts)            clean = gate(tool, mode, twin, passed)            checked += 1            if WIDTH[bad.disposition] > WIDTH[clean.disposition]:                found.append((mode.value, label,                              clean.disposition.value, bad.disposition.value))    return checked, founddef approve_on_failed(gate, tool, amounts):    """Decisions that offer 'approve' although a required verdict failed."""    found = []    for mode in Mode:        rule = POLICY[(tool, mode)]        for amount in amounts:            for check in rule.requires:                verdicts = {n: Verdict(n, n != check, "on no invoice")                            for n in rule.requires}                if "approve" in gate(tool, mode, amount, verdicts).allowed:                    found.append((mode.value, amount))    return foundamounts = [Decimal(a) for a in (    "10.00", "49.99", "50.00", "50.01", "120.00", "199.99", "200.00",    "200.01", "900.00", "1999.99", "2000.00", "2000.01", "5000.00")]for name, gate in (("check-first", decide_check_first), ("band-first", decide)):    checked, cases_found = widening_cases(gate, "issue_refund", amounts)    missing = [c for c in cases_found if c[1] == "no amount"]    print(f"{name}: {len(cases_found) - len(missing)} verdict widenings and "          f"{len(missing)} missing-input cases in {checked} pairs")    for mode, label, clean, bad in cases_found:        print(f"    {mode:<12} {label:<32} twin: {clean:<7} this: {bad}")    offered = approve_on_failed(gate, "issue_refund", amounts)    print(f"    'approve' offered on a failed verdict: {len(offered)}")

The grid holds every band edge with a value on either side, plus a few amounts in between. For queue-drain's automatic band that is 49.99, 50.00 and 50.01, and copilot gets the same around 200.00 and 2,000.00. Each mode also gets one missing-amount pair, whose twin worst_amount reads from the rule rather than from the grid. Thirteen amounts in two modes, plus those two pairs, give 28 comparisons per gate, and the function counts them rather than assuming. The output reports the 26 verdict pairs and the 2 missing-input pairs separately.

text
check-first: 14 verdict widenings and 2 missing-input cases in 28 pairs    copilot      2000.00 amount_on_invoice failed twin: refuse  this: escalate    copilot      2000.01 amount_on_invoice failed twin: refuse  this: escalate    copilot      5000.00 amount_on_invoice failed twin: refuse  this: escalate    copilot      no amount                        twin: refuse  this: escalate    queue-drain  50.00 amount_on_invoice failed   twin: refuse  this: escalate    queue-drain  50.01 amount_on_invoice failed   twin: refuse  this: escalate    queue-drain  120.00 amount_on_invoice failed  twin: refuse  this: escalate    queue-drain  199.99 amount_on_invoice failed  twin: refuse  this: escalate    queue-drain  200.00 amount_on_invoice failed  twin: refuse  this: escalate    queue-drain  200.01 amount_on_invoice failed  twin: refuse  this: escalate    queue-drain  900.00 amount_on_invoice failed  twin: refuse  this: escalate    queue-drain  1999.99 amount_on_invoice failed twin: refuse  this: escalate    queue-drain  2000.00 amount_on_invoice failed twin: refuse  this: escalate    queue-drain  2000.01 amount_on_invoice failed twin: refuse  this: escalate    queue-drain  5000.00 amount_on_invoice failed twin: refuse  this: escalate    queue-drain  no amount                        twin: refuse  this: escalate    'approve' offered on a failed verdict: 26band-first: 0 verdict widenings and 0 missing-input cases in 28 pairs    'approve' offered on a failed verdict: 0

Under the check-first gate, every failed check at or above 50.00 in queue-drain, and at or above 2,000.00 in copilot, widens. Each one is a refusal turned into an escalation, and the missing amount widens in both modes. The check-first gate also offers "approve" on every one of the 26 failed-verdict decisions. The band-first gate shows zero on all three counts.

The book has a test, test_a_thresholded_tool_with_no_amount_is_not_automatic, that pins the copilot no-amount escalation on purpose, so it is not an accident. It still breaks the property, because a reviewer offered "approve" on a refund with no amount is approving a number nobody wrote down.

Put the amounts on your own band edges and the test costs milliseconds. Part 6 checked owed decisions: whether each decision an action was owed was actually made. This test asks whether a decision moves the right way when its evidence gets worse.

Agent escalation: human approval vs human hand-off

Refusing a proposal does not end the customer's problem, and the band-first gate does not pretend it does. It separates two things a person can be asked for, and most designs call both of them "escalation".

"Approve this proposal" is a request to act. A reviewer sees exact bytes, a tool, an amount and an account, and a yes executes them. Such a request exists only below the review ceiling of the mode in which the gate decided, and only for a proposal whose required verdicts passed. In copilot that is the yellow cell. A green-cell proposal whose check failed also reaches a person, because a person present may decide anything code may, and its allowed set is edit or reject. In queue-drain, which has no refund review band, approval does not exist at all.

"Hand this ticket to a person" is a request for attention. A person gets the ticket, the conversation, and the hand-off note saying what the comparator found. Nothing they say executes anything. If they decide the customer is owed 120.00, they start a new proposal in copilot, and that proposal has its own gate decision, under copilot's bands, with a person present.

d2
grid-rows: 1
grid-gap: 40
approve: "Approve" {
  label.near: top-center
  style: {fill: "#FFF8DC"; stroke: "#C9A800"; font-color: "#2C2C2A"}
  a1: "ESCALATE in band\nverdicts passed" {style: {fill: "#FFD93D"; stroke: "#C9A800"; font-color: "#2C2C2A"}}
  a2: "reviewer sees\nexact bytes" {style: {fill: "#98D8C8"; stroke: "#5FA898"; font-color: "#2C2C2A"}}
  a3: "issue_refund\nruns as shown" {style: {fill: "#4A90E2"; stroke: "#2C6FB0"; font-color: "#FFFFFF"}}
  a1 -> a2: "shown"
  a2 -> a3: "yes"
}
handoff: "Hand off" {
  label.near: top-center
  style: {fill: "#EAF2FB"; stroke: "#2C6FB0"; font-color: "#2C2C2A"}
  h1: "escalate_to_human\nallowed in every mode" {style: {fill: "#6BCF7F"; stroke: "#3F9E52"; font-color: "#2C2C2A"}}
  h2: "person reads ticket\n+ hand-off note" {style: {fill: "#98D8C8"; stroke: "#5FA898"; font-color: "#2C2C2A"}}
  h3: "new proposal\nits own gate decision" {style: {fill: "#7B68EE"; stroke: "#5A4BC4"; font-color: "#FFFFFF"}}
  h1 -> h2 -> h3
}

Only approval ends at the tool. A hand-off ends at a new proposal that has to pass a gate like any other, which is why the hand-off can be unconditionally allowed in every mode. My book does this, with an unconditional escalate_to_human rule that the gate always allows, in both modes.

Any other decision in the harness can leave the run unable to proceed. A tool can be refused, or a breaker from Part 8 can be open. A deferral from Part 7's Deferral Rung reaches this gate with no proposal, and the gate refuses. Whatever gets the run out of those states must not be refusable by the logic that put it there. Being always allowed does not make the hand-off harmless, though. A person is an attack surface, and hand-off text that carries model wording ("customer is owed 940.00, please issue") is a channel straight to the person who writes the next proposal. So treat the content as untrusted: the hand-off note carries the comparator's structured finding, not the model's prose, and the hatch gets a rate bound like any other effect so it cannot flood the morning queue.

XACML's deny-biased enforcement point gives this split a standards precedent: "If the decision is 'Permit', then the PEP SHALL permit access. ... All other decisions SHALL result in the denial of access. Note: other actions, e.g. consultation of additional PDPs, reformulation/resubmission of the decision request, etc., are not prohibited." PEP means policy enforcement point, and PDP means policy decision point. Asking someone else is allowed alongside a denial. It does not turn the denial into a permit.

Part 6 needs a correction here, stated openly. Its decision-log check says a recorded human approval clears "a gate's refusal, and only a gate's". It also says that approval "cannot clear a comparator's factual verdict", so a 940.00 that a person approved still pages, because 940.00 is on no invoice.

Under this part's three dispositions, what Part 6 called a gate refusal is an ESCALATE inside a declared review band whose verdicts passed. A REFUSE is never clearable, and a person can only start a new proposal from the ticket. Part 6's comparator rule survives intact. A check-first gate asks a person to sign exactly the action that Part 6's check would then flag. Band first never offers that signature: inside the band a failed check becomes edit or reject, and outside it a refusal.

One change does follow for Part 6's check. Before it lets a human approval clear an escalation, it must confirm two things: the escalation fell inside the review band of the mode in which the gate decided, and "approve" was in its allowed set. Otherwise it clears exactly the widened approvals this part forbids. For that, the gate's control signal must record three facts: the disposition (escalated, not refused), the mode it decided in, and the allowed set. Part 6's closed Outcome enum has no escalated value, so an escalation there is recorded as a gate refused followed by a hand-off. It needs one more member, ESCALATED, and the mode and the allowed set fit as plain values under its 64-character cap.

Several gates in sequence raise the same question. My book composes them as "Every gate must allow. The first that does not ends the sequence." An escalation pauses that sequence, so an approval must resume it, and every gate after the escalating one runs on the approved proposal before the tool does. OpenAI works the same way when it re-checks tool input guardrails after approval. Part 14 adds the band gate where this matters most.

Binding human approval to the exact tool call

Separating the two requests only helps if approval really executes what was shown. A reviewer is shown a specific amount, account and tool, and if the system then executes something else, approval has become a path to an action nobody saw.

Current tooling has documented exactly that failure. For Google's Agent Development Kit (ADK) for Python before version 2.5.0, the National Vulnerability Database entry for CVE-2026-18236 says the framework "did not match the confirmation arguments against the original tool call event in the history". LangChain's human-in-the-loop documentation warns about its when predicate, which gates interrupts on a call's arguments: "The predicate runs again when the agent resumes, so it must return the same result for the same call. If it returns False on resume, the tool runs and the reviewer's answer is ignored, even a reject." In both, approval and action are not bound to the same bytes. Bind them: store the proposal with its decision record, and on approval execute only a proposal whose digest matches what the reviewer saw.

d2
direction: down
p: "proposal stored\nwith its digest" {style: {fill: "#4A90E2"; stroke: "#2C6FB0"; font-color: "#FFFFFF"}}
r: "reviewer sees\nthe stored bytes" {style: {fill: "#98D8C8"; stroke: "#5FA898"; font-color: "#2C2C2A"}}
c: "on approve:\nrecompute digest" {style: {fill: "#7B68EE"; stroke: "#5A4BC4"; font-color: "#FFFFFF"}}
run: "match:\ntool runs" {style: {fill: "#6BCF7F"; stroke: "#3F9E52"; font-color: "#2C2C2A"}}
stop: "mismatch:\nrefuse" {style: {fill: "#E74C3C"; stroke: "#A93226"; font-color: "#FFFFFF"}}
p -> r
r -> c: "approve"
c -> run
c -> stop

The digest is computed once, when the proposal is stored, and again at execution. Nothing between those two points can change what runs without turning the approval into a refusal, whether a predicate re-evaluated on resume or a forged confirmation. The bytes can match while the facts behind them have moved, which is the case for binding the approval to the evidence, not just the bytes.

What LangChain, OpenAI and Claude agent SDKs gate on

If you build this gate on a framework, you need to know what it decides for you and what it leaves to your code. The frameworks key approval on the tool and its arguments. The closest built-in equivalent of "nobody is present" is Claude's dontAsk permission mode, documented as deny instead of prompting. Elsewhere you can read presence from run state inside an approval predicate, but you have to write that yourself.

FrameworkApproval keyed onWhat a failed check doesPresence-aware?
LangChain HumanInTheLoopMiddleware (langchain 1.5.0)tool name; arguments through when (langchain 1.3.3 or later)approve, edit, reject, respond; no refuse outcome in the middlewareno
OpenAI Agents SDK (docs as of 2026-11-14)needs_approval, True or a callable over the parsed argumentsguardrail tripwire raises; tool input guardrails run after approval, just before executionno
Claude Agent SDK (docs as of 2026-11-14)deny, ask and allow rules, permission mode, canUseTooldeny rules win over hooks and modesyes: dontAsk turns every prompt into a denial
Check-first gate abovetool, mode, amount band, verdictsescalates before the band is readyes, but widens
Band-first gate abovetool, mode, amount band, verdictsnarrows within the band, hands off otherwiseyes

For guardrails, OpenAI's ordering is narrow-only by default. Its documentation says tool input guardrails "normally run after approval and immediately before execution", and that calls passing an optional pre-approval check "are still checked again after approval before the tool executes". So an approval cannot carry a proposal past a tripped tool input guardrail.

Claude's dontAsk mode is the closest production version of the bottom row of the Consequence Gating grid: "Any call that would otherwise prompt is denied without calling canUseTool." A mode with nobody to answer a prompt has no review band, and the vendor built that in. No framework ships per-amount bands as policy, although you can write one inside a when or needs_approval predicate. Claude's mode is global, and a PreToolUse hook that reads the amount is the only way to make it per-amount, so under the mode alone a refund of 40.00 and one of 4,000.00 get the same ceiling. Writing the amount band is still your job.

Hard blocks vs overridable alerts: the Citi 2022 trading error

Agents did not invent this failure. On 2 May 2022 a trader at Citigroup Global Markets meant to sell a basket of equities worth USD 58m and entered one worth USD 444bn. For the control failures, the Financial Conduct Authority (FCA) fined the firm GBP 27,766,200. Its press release says "CGML controls blocked US$255bn of the basket progressing, but not the remaining US$189bn", and USD 1.4bn of it was sold.

d2
grid-rows: 1
grid-gap: 40
hard: "Blocked" {
  label.near: top-center
  style: {fill: "#EAF7EE"; stroke: "#3F9E52"; font-color: "#2C2C2A"}
  h1: "erroneous basket\nUSD 444bn" {style: {fill: "#4A90E2"; stroke: "#2C6FB0"; font-color: "#FFFFFF"}}
  h2: "controls\nblocked it" {style: {fill: "#E74C3C"; stroke: "#A93226"; font-color: "#FFFFFF"}}
  h3: "USD 255bn\nstopped" {style: {fill: "#6BCF7F"; stroke: "#3F9E52"; font-color: "#2C2C2A"}}
  h1 -> h2 -> h3
}
soft: "Overridable" {
  label.near: top-center
  style: {fill: "#FDECEA"; stroke: "#C0392B"; font-color: "#2C2C2A"}
  s1: "remaining\nUSD 189bn" {style: {fill: "#4A90E2"; stroke: "#2C6FB0"; font-color: "#FFFFFF"}}
  s2: "pop-up alert\nperson may override" {style: {fill: "#FFD93D"; stroke: "#C9A800"; font-color: "#2C2C2A"}}
  s3: "to the algorithm\nUSD 1.4bn sold" {style: {fill: "#E74C3C"; stroke: "#A93226"; font-color: "#FFFFFF"}}
  s1 -> s2
  s2 -> s3: "overridden"
}

The blocks that held were not ones the trader overrode. Where a person was allowed to say yes, on the right, the control failed. Both halves are in the FCA's account: the trader "was also able to manually override a pop-up alert, without being required to scroll down and read all the alerts within it", and "there was no hard block that would have rejected this large erroneous basket of equities in its entirety."

This is a structural analogue from trading. Whoever overrode the alert was also the one acting, and the input was a keying error rather than a model's proposal. Its lesson carries over anyway. A control whose warning can be overridden is a review band. For amounts where nobody should be able to say yes, the control has to be one nobody can override. A check-first gate puts an approvable path in exactly that place, and it does so for the proposals its own comparators flagged.

So a gate that cannot know whether 940.00 is right should not pretend to. It should decide who may be wrong about 940.00 tonight, and let its checks only make that answer stricter. If a failed check can ever buy a proposal a signature line its clean twin would not get, the gate has handed its weakest evidence its strongest path.

Checklist: approval gates that do not widen

  1. Write the band per tool and per mode. Each rule names who may decide at each amount, in a mode where somebody is present and in one where nobody is. In a mode with nobody present, an irreversible tool has no review band. Leave the key out rather than writing a threshold of zero.
  2. Read the band before the verdicts. A failed verdict escalates only if the band lets a person in this mode approve this amount. Otherwise it refuses and attaches the finding to the ticket.
  3. Refuse a thresholded tool with no amount, in every mode. There is nothing exact to approve.
  4. Run the widening test in CI. For every tool, mode and required check, a failed check must never return more authority than a passed one, and a missing amount must never beat the first amount the band never allows. Put amounts on and around every band edge.
  5. Keep two human requests separate. "Approve this proposal" exists only inside a review band and executes exactly what was shown. "Hand this ticket to a person" is always allowed, carries the structured finding rather than model prose, and never reaches the tool.
  6. Make the reviewer's allowed decisions part of the Decision, not its reason text, and bind approval to the bytes. Store the proposal's digest with the decision, and execute only a proposal whose digest matches what the reviewer saw. Make any approval predicate deterministic for the same call, or bypass it on resume by matching the stored digest.
  7. Count refusals with a hand-off apart from plain refusals. Hand-offs are coverage the morning queue has to absorb. If they grow, revisit the band, not the gate order.
  8. Audit vendor glue for deny-as-hold. Search your code for any branch that turns a deny into a queued approval. Each one is a review band nobody wrote into the policy.

Gated execution for AI agents: the full chapter

This is Part 9 of a series that follows Harness Engineering for Production AI Systems one chapter at a time. Chapter 9, "Gated Execution," covers what this part leaves out. It explains why fail-closed is three separate decisions: no rule, no verdict, no amount. It shows how the gate protocol generalises so that an admission gate can be registered too. It works through several gates in one order, and through what a human review tier really costs: the asynchronous run, the timeout nobody chose, and what the reviewer sees. It also covers tuning bands from the refusal record rather than from incidents, and why a model must not choose its own tier. My chapter defends the check-first ordering, and this part is my correction to it, so the widening test above is the thing to run against the companion code. Code for the chapter is the ch09-gated-execution tag of the companion repository, and its tests need no model and no API key.

References

Book and series:

External (web pages accessed 2026-11-14):


AI Security

Agentic AI

Follow for more technical deep dives on AI/ML systems, production engineering, and building real-world applications:


Books by Ranjan Kumar

Federated AI Agents cover

Federated AI Agents

Right-Sized AI cover

Right-Sized AI

Harness Engineering for Production AI Systems cover

Harness Engineering

The 7 GenAI Architectures cover

The 7 GenAI Architectures

Building Real-World Agentic AI Systems with LangGraph cover

Building Real-World Agentic AI Systems

The ChatML Handbook cover

The ChatML Handbook

The Chat Templates Handbook cover

The Chat Templates Handbook

Comments