Hey everyone! 👋 I've been deep in the weeds building a reporting dashboard where user-inputted numbers directly feed into some heavy-duty calculations (think LTV projections, ROI on ad spend, etc.). I learned the hard way that a single non-numeric character—or even an empty field—can cause the entire pipeline to throw an error or, worse, produce wildly inaccurate results silently.
So, I've spent the last week refining a robust validation layer for my agent. I wanted to share my complete "recipe" for ensuring every numeric input is rigorously checked *before* any math happens. The goal is to catch issues early, provide clear feedback to the user, and maintain data integrity. This is especially crucial when your agent automates tasks based on these inputs.
Here's my approach, broken down into the validation logic, the agent configuration, and the error handling flow.
### Core Validation Logic (Python Function)
I placed this in a dedicated utility module that my agent can call. It's designed to be flexible for integers, floats, and even within specified ranges (common for percentages, budgets, etc.).
```python
def validate_numeric_input(input_value, expected_type='float', min_val=None, max_val=None, field_name="Input"):
"""
Validates a numeric input string or value.
Args:
input_value: The raw input (usually a string from user).
expected_type: 'int' or 'float'.
min_val: Optional minimum acceptable value.
max_val: Optional maximum acceptable value.
field_name: Name of the field for error messaging.
Returns:
A tuple (is_valid: bool, message: str, converted_value).
"""
if input_value is None or (isinstance(input_value, str) and input_value.strip() == ''):
return False, f"{field_name} cannot be empty.", None
try:
# Convert based on expected type
if expected_type == 'int':
converted = int(input_value)
else: # 'float'
converted = float(input_value)
# Range validation
if min_val is not None and converted max_val:
return False, f"{field_name} ({converted}) must be no more than {max_val}.", None
return True, "Valid.", converted
except ValueError:
return False, f"{field_name} ('{input_value}') must be a valid {expected_type}.", None
```
### Agent Configuration & Prompt Engineering
In my agent's system prompt (or instruction set), I explicitly define the validation step as a non-negotiable first action. Here's a snippet from my setup:
```yaml
agent_config:
name: "Calculation_Agent"
capabilities:
- "execute_calculations"
- "validate_inputs"
steps:
- name: "input_validation"
description: "Validate ALL user-provided numeric fields using the 'validate_numeric_input' function before proceeding."
mandatory: true
```
More importantly, I structure the operational prompt to enforce this:
> "Before beginning any calculations, you MUST validate each numeric input provided by the user. Use the `validate_numeric_input` function for each parameter. If any validation fails, immediately stop and present the error message to the user. Do not proceed with calculations until all inputs are valid."
### Example Conversation Flow & Error Handling
A typical interaction now looks like this:
**User:** "Calculate the ROI for a campaign budget of '5OO' (with a letter O), revenue of 10000, and expenses of two thousand."
**Agent Thought Process:**
1. Calls `validate_numeric_input('5OO', 'float', min_val=0, field_name="Campaign Budget")` → **Fails**. Returns message: "Campaign Budget ('5OO') must be a valid float."
2. **Stops immediately**. Does not proceed to validate revenue or expenses.
3. **Output to User:** "I need to validate your inputs first. ❌ Validation failed for 'Campaign Budget': '5OO' must be a valid number. Please correct this value, and I'll check the others."
This forces a correction cycle. Once the user fixes it to "500":
**Agent Thought Process:**
1. Budget validation passes.
2. Validates revenue ('10000') → passes.
3. Validates expenses ('two thousand') → fails with a clear message.
4. **Output to User:** "Thanks for the correction on Budget. However, validation failed for 'Expenses': 'two thousand' must be a valid number. Please provide it as a numeric value (e.g., 2000)."
### Results & Key Takeaways
Since implementing this:
* **Error Reduction:** Calculation runtime errors dropped to near zero.
* **User Experience:** Feedback is immediate and specific, guiding users to fix issues quickly instead of facing a generic "something went wrong" later.
* **Data Quality:** I have high confidence that any calculation running has received sanitized, type-safe inputs.
The critical lesson was **making validation a separate, mandatory step in the agent's chain-of-thought**, not something it "might" do. This pattern has been a game-changer for any numeric-heavy agent I've built since.
I'd love to hear how others approach this! Do you use similar pre-flight checks, or have you found other patterns for input sanitization in your agents?