Photo by editor
# Introduction
If you’ve built AI agents that work perfectly in your notebook but when they hit production, your company is good. API call times out, large language model (LLM) responses are returned in an incorrect format. And rate caps kick in at the worst possible moment..
The reality of deploying agents is messy, and most of the pain comes from handling failure gracefully. Here’s the thing – you don’t need a massive framework to solve this. These five Python decorators have saved me countless headaches, and they’ll probably save you too.
# 1. Automatic retry with exponential backoff
Every AI agent talks to external APIs, and every external API will eventually fail on you. Maybe it’s OpenAI returning a 429 because you’ve exceeded the rate limit, or maybe it’s just a brief network hiccup. Either way, your agent shouldn’t just give up at the first failure.
Oh @retry A decorator wraps any function so that when it raises a specific exception, it waits a moment and tries again. The exponential backoff part is very important because you want the wait time to increase with each attempt. The first retry waits one second, the second retry waits two, the third waits four, and so on. This prevents you from hammering out an already struggling API.
You can make it yourself using a simple wrapper. time.sleep() and a loop, Or visit the Tennessee Library.which gives you a battle trial. @retry Out of the decorator box. The key is to configure it with the correct exception types. You don’t want to retry on bad prompts (which will fail every time), but you definitely want to retry on connection errors and rate limit responses.
# 2. Use of time-out guards
LLM calls may hang. It doesn’t happen often, but when it does, your agent sits there doing nothing while the user stares at the spinner. Even worse, if you’re running multiple agents in parallel, a single hang call can block your entire pipeline.
Oh @timeout The decorator Sets a hard limit on how long any function is allowed to run.. If the function doesn’t return within, say, 30 seconds, the decorator raises a. TimeoutError Which you can hold and handle well. A typical implementation uses Python’s signal A module for synchronous code or asyncio.wait_for() if you’re working in async land..
Combine this with your retry decorator and you’ve got a powerful combo: if the call hangs, a timeout kills it, and the retry logic starts over with a new attempt. This alone eliminates a large category of production failures.
# 3. Implementing response caching
This is something that will dramatically reduce your API costs. If your agent makes the same call with the same parameters multiple times (and they often do, especially in multi-step reasoning loops), there’s no reason to pay twice for that response.
Oh @cache The decorator Stores the result of a function call based on its input arguments.. The next time the function is called with the same arguments, the decorator returns the stored result immediately. Python built-in functools.lru_cache Works great for simple cases, but for agent workflows, you want something with time-to-live (TTL) support so that cached responses expire after a reasonable window.
It matters more than you think. Agents that use the tool calling pattern often reconfirm previous results or retrieve context that they already obtained. Cashing these calls means faster processing and a lighter bill at the end of the month.
# 4. Validating inputs and outputs
Large language models are unpredictable by nature. You send a carefully crafted prompt for JSON, and sometimes you get back a Markdown code block with a trailing comma that breaks your parser. Oh @validate Decorator catches these problems at the boundary, before bad data seeps deep into your agent logic.
On the input side, the decorator checks that the arguments your function receives match the expected types and constraints. On the output side, it verifies that the return value matches the schema, Pydantic makes this incredibly clean.. You define your expected response as a Pydantic model, and the decorator tries to parse the LLM output into that model. If authentication fails, you can try the call again, apply a fixup function, or revert to the default.
The real win here is that validation decorators turn silent data corruption into loud, catchable errors. You’ll debug problems in minutes instead of hours.
# 5. Building fallback chains
Production agents need a plan B. If your underlying model is closed, if your vector database is inaccessible, if your tool API returns garbage, your agent should gracefully degrade rather than crash.
Oh @fallback The decorator Lets you define a chain of substitution functions.. The decorator first tries the primary function, and if it throws an exception, it moves to the next function in the chain. You can set the fallback to the native Llama model from GPT-5.4 to Claude. or from a cached snapshot from a live database query to a hardcoded default.
Implementation is straightforward. The decorator accepts a list of fallback callables and iterates through them on failure. You can get fancy with this by adding logging at each fallback level so you know exactly where and why your system crashed. This pattern appears everywhere in production machine learning systems, and having it as a decorator keeps the logic separate from your business code.
# The result
Decorators are one of Python’s most underappreciated features when it comes to building reliable AI agents. The five patterns included here show the most common failure modes you’ll encounter after your agent leaves the security of a Jupyter notebook.
And they compose beautifully. Stack a @retry Above one @timeout Above one @validateand you’ve got a function that won’t hang, won’t abort too easily, and won’t silently transmit bad data downstream. Get started today by adding retry logic to your API calls. Once you see how clean your error handling becomes, you’ll want decorators everywhere.
Nala Davis is a software developer and tech writer. Before devoting his career full-time to technical writing, he founded an Inc. 5,000 to serve as lead programmer at an experiential branding organization—among other exciting things—whose clients include Samsung, Time Warner, Netflix, and Sony.