Lilly Tech Systems
Agent Best Practices
Lessons learned from building production AI agents. Covers reliability, cost management, safety, debugging, and the most common pitfalls to avoid.
Reliability and Error Handling
- Always set max steps: Every agent loop must have a hard limit on iterations to prevent runaway execution
- Implement timeouts: Set timeouts on every tool call. A hanging API call should not block the agent forever
- Retry with backoff: Use exponential backoff for transient failures (API rate limits, network errors)
- Graceful degradation: If a tool fails, the agent should adapt rather than crash. Provide the error context to the LLM and let it reason about alternatives
- Checkpointing: For long tasks, save state periodically so the agent can resume after failures
- Idempotent tools: Design tools so that running them multiple times produces the same result. This makes retries safe
Cost Management
- Token budgets: Set per-task token limits. Track input and output tokens separately.
- Model tiering: Use cheap models for simple steps, expensive models only for complex reasoning
- Context management: Do not send the full conversation history if a summary suffices. Trim irrelevant tool results
- Caching: Cache tool results that are unlikely to change (documentation, static data)
- Early termination: If the agent has enough information, stop searching. Do not over-research
- Monitor costs: Track cost per task and set alerts for anomalies
Safety and Alignment
- Principle of least privilege: Give the agent only the permissions it needs. A research agent should not have file delete access
- Confirmation gates: Require human approval for irreversible actions (sending emails, making purchases, modifying production data)
- Input sanitization: Validate all tool inputs. Prevent prompt injection through user-supplied data
- Output filtering: Check agent outputs before presenting to users. Filter PII, harmful content, or confidential data
- Audit trail: Log every decision and action. This is essential for debugging and compliance
Evaluation Metrics
| Metric | What It Measures | Target |
|---|---|---|
| Task completion rate | Percentage of tasks finished successfully | > 90% |
| Accuracy | Correctness of agent outputs | > 95% |
| Steps per task | Efficiency of the agent | Minimize |
| Cost per task | API and compute costs | Below budget |
| Latency (p50/p95) | Response time | Depends on use case |
| Error rate | Frequency of failures | < 5% |
| Human escalation rate | How often the agent needs human help | < 10% |
Debugging Agents
- Trace logging: Log every LLM call (input/output), every tool call, and every decision point
- Replay capability: Save complete conversation histories so you can replay and debug failed tasks
- Step-through mode: Build a mode where the agent pauses after each step for human inspection
- Visualization: For complex agents, visualize the execution graph to understand flow
- Common failure patterns: Agent loops (repeating the same action), wrong tool selection, context overflow, hallucinated tool parameters
Scaling Agent Systems
- Async execution: Use async/await for tool calls to avoid blocking on I/O operations
- Queue-based processing: For high volume, put tasks in a queue and process with worker agents
- Horizontal scaling: Run multiple agent instances behind a load balancer
- Rate limit management: Implement per-provider rate limiting to avoid hitting API limits
Human-in-the-Loop Patterns
- Approval gates: Agent pauses at key decision points for human approval
- Confidence-based routing: Agent handles high-confidence tasks autonomously, routes low-confidence tasks to humans
- Review before publish: Agent generates output, human reviews before it is sent/published
- Escalation: Agent recognizes when it is stuck or uncertain and requests human help
Common Pitfalls
- Too many tools: Giving the agent 50+ tools overwhelms the LLM. Keep it focused.
- No guardrails: An unguarded agent will eventually do something unintended.
- Ignoring cost: Agent loops can run up huge API bills in minutes.
- Over-engineering: Start simple. Add complexity only when needed.
- Poor tool descriptions: Vague tool descriptions lead to wrong tool selection.
- No testing: Agents need testing even more than traditional software.
- Blind trust: Never assume the agent output is correct. Validate critical outputs.
Frequently Asked Questions
What is the best LLM for building agents?
Claude Opus 4 and Sonnet 4 currently lead for agentic tasks due to their sustained performance on long, multi-step tasks and reliable tool use. GPT-4o and o3/o4-mini are also strong choices. The best model depends on your specific requirements for cost, speed, and capability.
Do I need a framework to build agents?
No. Many production agents are built directly on provider APIs (Anthropic, OpenAI) with custom code. Frameworks like LangGraph and CrewAI can accelerate development but add complexity. Start without a framework to understand the fundamentals, then adopt one if it solves a real problem.
How do I prevent agents from going rogue?
Implement multiple layers of safety: max step limits, token budgets, action whitelists, human approval for high-risk actions, sandboxed execution environments, and comprehensive logging. The principle of least privilege is your best defense.
How much does it cost to run an agent?
Costs vary widely. A simple agent answering a question might use $0.01-0.05 in API calls. A complex research agent running 20+ steps could use $0.50-5.00 per task. Monitor costs carefully and set budgets per task.
Can I use open-source models for agents?
Yes, though with trade-offs. Models like Llama 3.3 70B and Qwen 2.5 72B support function calling and can power agents. They may require more prompt engineering and be less reliable at complex tool use compared to frontier models. They are excellent for privacy-sensitive deployments and cost control.