Enforcing Stop Conditions

Build an agent loop that can stop for more than one reason. A basic loop stops when the model says it is done, but a production agent also has to stop when it has taken too many steps or spent too long. This exercise is the control logic that enforces all three limits and reports which one fired.

How the limits work

You keep a running list of messages and, each turn, call model(messages). The loop must respect three stop conditions and return the reason for the one that triggers first:

• Final answer — the model returns {"type": "final", "content": "..."}. Stop and return (content, "final").
• Step cap — you have made max_steps model calls without a final answer. Stop and return (None, "max_steps").
• Time budget — the elapsed time (measured with the injected clock) has reached time_budget. Stop and return (None, "budget").

clock is a zero-argument callable that returns a number that only increases (think seconds). Record the start time once, then compare clock() - start against time_budget before each model call. Because the clock is passed in, the whole loop is deterministic: the same clock stub always produces the same result.

Task

Complete run_with_limits(model, tools, user_msg, clock, max_steps=10, time_budget=None):

1. Start messages with {"role": "user", "content": user_msg} and record start = clock().
2. Before each model call, if time_budget is not None and clock() - start >= time_budget, stop with (None, "budget").
3. Otherwise call the model. On a final answer return (content, "final"). On a tool call, append the assistant message, run the named tool, and append {"role": "tool", "name": ..., "content": <output>}.
4. Allow at most max_steps model calls. If they are exhausted with no final answer, return (None, "max_steps").

Example

def make_clock(step=1.0, start=0.0):
    # returns start, start+step, start+2*step, ... on successive calls
    t = {"now": start}
    def clock():
        v = t["now"]; t["now"] += step; return v
    return clock

def never_finishes(messages):
    # always asks for a tool, so only a limit can stop the loop
    return {"role": "assistant", "type": "tool", "name": "noop", "args": {}}

tools = {"noop": lambda args: "ok"}

# clock ticks 0,1,2,3,...; budget of 3 stops before the 3rd model call
run_with_limits(never_finishes, tools, "go", make_clock(), max_steps=10, time_budget=3)
# -> (None, "budget")

def finishes(messages):
    return {"role": "assistant", "type": "final", "content": "done"}

run_with_limits(finishes, tools, "go", make_clock(), max_steps=10, time_budget=3)
# -> ("done", "final")

Constraints

• Check the time budget before spending a model call, so an already-exhausted budget stops immediately.
• Handle an unknown tool name gracefully (append an error result rather than crashing).
• Do not call any real LLM, network, or wall clock — model, the tools, and clock are all provided.

Approach

The loop is bounded by range(max_steps), which handles the step cap for free. Inside each iteration, before spending a model call, we compare injected clock() against a recorded start time to enforce the time budget. The model’s final answer is the third exit. Each exit returns a (answer, reason) pair so the caller knows which condition fired.

Solution

from typing import Callable, Optional, Tuple

def run_with_limits(
    model,
    tools: dict,
    user_msg: str,
    clock: Callable[[], float],
    max_steps: int = 10,
    time_budget: Optional[float] = None,
) -> Tuple[Optional[str], str]:
    messages = [{"role": "user", "content": user_msg}]
    start = clock()

    for _ in range(max_steps):
        # time budget: check before spending a model call
        if time_budget is not None and clock() - start >= time_budget:
            return (None, "budget")

        action = model(messages)

        if action["type"] == "final":
            return (action["content"], "final")

        # otherwise it's a tool call
        name, args = action["name"], action.get("args", {})
        messages.append(action)                      # record what the model asked for

        tool = tools.get(name)
        if tool is None:
            result = f"error: unknown tool '{name}'"
        else:
            try:
                result = tool(args)
            except Exception as e:                   # a broken tool shouldn't crash the agent
                result = f"error: {e}"

        messages.append({"role": "tool", "name": name, "content": result})

    # exhausted the step cap without finishing
    return (None, "max_steps")

Walkthrough

On the budget example, make_clock() returns 0, 1, 2, 3, ... on successive calls and never_finishes always asks for the noop tool:

1. start = clock() -> 0.
2. Iteration 1: clock() -> 1, 1 - 0 = 1 < 3, so call the model. It returns a tool call; run noop -> "ok", append both messages.
3. Iteration 2: clock() -> 2, 2 < 3, run the tool again.
4. Iteration 3: clock() -> 3, 3 - 0 = 3 >= 3, so we stop before calling the model and return (None, "budget").

On the finish example, finishes returns a final answer on the first model call, so iteration 1 checks the budget (1 < 3), calls the model, sees type == "final", and returns ("done", "final") — the natural exit wins because it fires before either limit.

Complexity & notes

• Time is O(steps × model/tool cost); the loop bookkeeping is O(1) per step. Space is O(total messages).
• Checking the budget before the model call means an already-blown budget stops immediately and never pays for another (possibly expensive) model turn. Checking after would let one extra call slip through.
• Injecting clock is the key testability move: real code would pass time.monotonic, but a stub clock makes the loop deterministic and unit-testable without sleeping. Use a monotonic source, never time.time, which can jump backward.
• The three conditions are checked in a fixed order (budget, then final, then the for bound), so ties resolve predictably — worth stating explicitly in an interview.
• Real systems add more budgets on the same skeleton: token counts, dollar cost, and tool-call quotas each become another guard clause returning its own reason string.