Agent Reliability

def verify_answer(answer: str, state) -> list[str]:
    """Checks in code that a reply matches what actually happened."""
    problems = []
    done = {a.name for a in state.actions if a.succeeded}
    if claims_refund(answer) and "refund_item" not in done and "refund_delivery_fee" not in done:
        problems.append("Reply claims a refund, but no refund tool succeeded.")
    for amount in amounts_in(answer):
        if amount not in state.amounts_seen:                  # every ₹ figure must come from a tool
            problems.append(f"Amount ₹{amount} does not appear in any tool result.")
    for order_id in order_ids_in(answer):
        if order_id not in state.order_ids_seen:
            problems.append(f"Order {order_id} was never returned by a tool.")
    return problems

def check_call(call, state) -> str | None:
    """Return an error message the model can act on, or None if the call may run."""
    tool = REGISTRY.get(call.name)
    if tool is None:
        metrics.count("tool.hallucinated", tool=call.name)
        return f"There is no tool '{call.name}'. Available tools: {', '.join(sorted(REGISTRY))}."
    if problem := tool.validate(call.input):                       # JSON Schema
        metrics.count("tool.invalid_params", tool=call.name)
        return f"Invalid input for {call.name}: {problem}. Correct it and try again."
    if (oid := call.input.get("order_id")) and oid not in state.order_ids_seen:
        return (f"Order {oid} has not been returned by any tool in this conversation. "
                "Use get_recent_orders to find the right id.")
    return None

def idempotency_key(run_id: str, call) -> str:
    """The same logical action always gets the same key, however often it is attempted."""
    return f"{run_id}:{call.name}:{stable_hash(call.input)}"

def refund_item(order_id: int, amount: int, *, idempotency_key: str) -> str:
    existing = payments.find_by_key(idempotency_key)
    if existing:                                        # a retry, a loop or a resumed run
        return f"Already refunded ₹{existing.amount} for order {order_id}. Nothing more was done."
    refund = payments.create_refund(order_id, amount, key=idempotency_key)
    return f"Refunded ₹{refund.amount} for order {order_id}."

def looping(actions: list) -> bool:
    recent = [(a.name, stable_hash(a.input)) for a in actions[-4:]]
    return (len(recent) == 4 and
            (len(set(recent)) == 1 or recent[:2] == recent[2:]))     # AAAA or ABAB

COMPLETENESS_PROMPT = """The customer asked for the following. List each separate request.
Then, for each, say whether the transcript shows it was DONE, REFUSED WITH A REASON,
or NOT ADDRESSED. Return JSON: {{"requests": [{{"request": "...", "status": "..."}}]}}

Customer's original message: {goal}
What the agent did: {actions}
Final reply: {answer}"""

def unaddressed(goal: str, state, answer: str) -> list[str]:
    result = llm_small_json(COMPLETENESS_PROMPT.format(goal=goal, actions=state.action_log(), answer=answer))
    return [r["request"] for r in result["requests"] if r["status"] == "NOT ADDRESSED"]

def cancel_order(order_id: int, user) -> str:
    """Re-read before writing: never act on a status remembered from earlier."""
    order = orders.get(order_id, user=user)             # fresh read, inside the tool
    if order.status != "preparing":
        return f"Cannot cancel: order {order_id} is now '{order.status}'."
    orders.cancel(order_id, expected_version=order.version)    # fails if it changed meanwhile
    return f"Order {order_id} cancelled."

def render_memory(memory) -> str:
    return f"- {memory.text} (noted {memory.created}, from {memory.source})"   # age is visible

class CircuitBreaker:
    """After repeated failures, stop calling a dependency for a while."""
    def __init__(self, threshold: int = 5, cool_off_seconds: int = 30):
        self.failures, self.opened_at = 0, None
        self.threshold, self.cool_off = threshold, cool_off_seconds

    def call(self, fn, *args):
        if self.opened_at and now() - self.opened_at < self.cool_off:
            raise DependencyUnavailable("Circuit open: failing fast instead of waiting.")
        try:
            result = fn(*args)
        except (TimeoutError, ConnectionError):
            self.failures += 1
            if self.failures >= self.threshold:
                self.opened_at = now()                 # open the circuit
            raise
        self.failures, self.opened_at = 0, None        # success closes it
        return result

STEPS = [
    Step("hold_slot",    do=hold_delivery_slot,   undo=release_delivery_slot),
    Step("charge",       do=charge_reschedule_fee, undo=refund_reschedule_fee),
    Step("confirm_slot", do=confirm_delivery_slot, undo=None),      # hardest to undo: last
    Step("notify",       do=send_confirmation,     undo=None),      # failure here is tolerable
]

def run_saga(state) -> str:
    for step in STEPS:
        if step.name in state.completed:
            continue                                   # resuming: skip what is already done
        try:
            step.do(state, idempotency_key=f"{state.run_id}:{step.name}")
            state.completed.append(step.name); save(state)
        except PermanentFailure as error:
            for done in reversed([s for s in STEPS if s.name in state.completed and s.undo]):
                done.undo(state, idempotency_key=f"{state.run_id}:{done.name}:undo")
            return f"Could not reschedule ({error}). Nothing was changed and you were not charged."
    return "Your delivery is rescheduled."

Q: Why do agents fail on long tasks?

Errors compound: task success is roughly per-step success raised to the number of steps. At 95 percent per step, twenty steps succeed about a third of the time. Fix by more reliable steps, shorter tasks and checks between steps.

Q: How would you prevent infinite agent loops?

Hard limits on steps, cost and time; detection of identical or alternating calls; one corrective nudge; then a hand-over with a summary. And fix the cause: tool results and errors that say what to try next.

Q: How do you prevent the same action happening twice?

Idempotency keys derived from the run and the action, so a retry, a loop or a resumed run performs the write once; plus an action ledger in state checked before any write.

Q: How do you reduce hallucination in an agent?

Give it facts through tools, make empty results explicit, require looking up before stating, and verify the final answer in code against tool results and the action log. Confirm actions in the system of record.

Q: The model calls a tool that does not exist. What happens?

The executor returns an error result listing the real tools; the model corrects itself. It is counted as a metric, and strict tool schemas plus a shorter tool list reduce its frequency.

Q: What is a cascading failure and how do you contain it?

One error spreading through a run, between agents or between systems. Contain it with validation at boundaries, timeouts, circuit breakers, bulkheads between tenants and bounded retries.

Q: A task fails half-way through. What do you do?

Know what was done from the ledger, resume from the checkpoint with idempotent tools, compensate for steps that must not stand alone, order steps so the least reversible is last, and report truthfully.

Q: What is stale memory and how do you avoid acting on it?

A remembered fact that is no longer true. Timestamp and expire memories, and re-read any fact an action depends on inside the tool, immediately before acting.

Your task. Inject each failure mode from the catalogue into your agent, watch it fail, add the defence, and confirm the failure is contained.

Steps

1. Write a fault-injection wrapper for your fake tools that can: time out, return an empty result, return an error, succeed but lose the reply, and return stale data.
2. Make refund_item succeed but raise a timeout on the first attempt. Confirm a double refund occurs, then add idempotency keys and confirm it does not.
3. Make a search tool always return 'Error'. Confirm a loop, then add repeat detection and a helpful error message.
4. Change an order's status between the agent's check and its cancel call. Add a re-read inside the cancel tool.
5. Crash the process after the charge step of a three-step action. Add a ledger and compensation.
6. Add the answer-verification check and feed it a reply that claims an action that did not happen.
7. Compute your task success rate over twenty runs with faults enabled at 10 percent, before and after the defences.

You are done when

• Each injected fault has a test that fails without the defence and passes with it.
• No fault you can inject produces a duplicate write.
• Every forced stop ends with an accurate account of what was and was not done.
• You have before-and-after task success rates under injected faults.

Stretch. Add a circuit breaker to one tool and show the agent degrades gracefully when the dependency is fully down.