Agent Development

Building reliable LLM agents with tools, memory, and guardrails.

Quick Start

pip install openai
# define tools, a loop, and safety limits

When to Use

• Automating multi-step tasks that need decisions
• Coding assistants, research agents, customer support
• Workflows that call tools and iterate
• When a single prompt is not enough

Best Practices

Tool Design

• Give tools clear names, descriptions, and JSON schemas
• Make tools deterministic and side-effect-aware
• Validate tool inputs; return structured errors
• Keep the tool surface small and focused

Agent Loop

• Structure: perceive -> decide -> act -> observe
• Cap the number of steps (max_iterations)
• Detect loops and stuck states; add a stop condition
• Log every step (tool, input, output) for debugging

Memory

• Use short-term context + long-term store (vector DB)
• Summarize conversation to fit context windows
• Persist important state across sessions
• Separate user facts from session facts

Safety

• Restrict destructive tools (delete, deploy, pay) with approvals
• Sandbox code execution; deny dangerous commands
• Add guardrails: content filters, budget limits, timeouts
• Escape prompt injection in tool outputs and user data

Dependencies

pip install openai pydantic
# optional: langgraph, crewai, or your own loop

Examples

from pydantic import BaseModel, Field

class WeatherTool:
    name = "get_weather"
    description = "Get current weather for a city"
    schema = {
        "type": "object",
        "properties": {"city": {"type": "string"}},
        "required": ["city"],
    }

    def run(self, city: str) -> str:
        return f"Weather in {city}: sunny, 22C"

# Minimal agent loop with max steps
def run_agent(user_input: str, tools: dict, max_steps: int = 10) -> str:
    messages = [{"role": "user", "content": user_input}]
    for _ in range(max_steps):
        resp = call_llm(messages, tools=list(tools.values()))
        if not resp.tool_calls:
            return resp.content
        for call in resp.tool_calls:
            result = tools[call.function.name].run(**call.function.arguments)
            messages.append({"role": "tool", "tool_call_id": call.id, "content": result})
    return "Reached max steps without final answer."

# Approval gate for destructive actions
def run_tool_safe(name: str, args: dict) -> str:
    if name in DANGEROUS_TOOLS:
        if not confirm(f"Approve {name}({args})? "):
            return "Action denied by user."
    return tools[name].run(**args)

# Summarize context to fit window
def compress(messages, keep_last=6):
    head = messages[:2]                      # system + original
    tail = messages[-keep_last:]
    summary = summarize(messages[2:-keep_last])
    return head + [{"role": "assistant", "content": f"[Summary] {summary}"}] + tail

Step-by-Step

1. Define the agent's goal, inputs, and stopping criteria.

2. Design a small set of tools with clear schemas.

3. Implement the perceive-decide-act loop with max steps.

4. Add memory: short-term context and persistent store.

5. Gate dangerous actions behind approvals.

6. Add guardrails: budget, timeout, content filters.

7. Evaluate on a benchmark of representative tasks.

8. Log traces for debugging and regressions.

Validation

1. Agent completes tasks within max steps

2. No infinite loops or repeated identical actions

3. Destructive tools require approval

4. Tool errors are handled gracefully (retry or explain)

5. Cost and latency within budget on the eval set

Troubleshooting

• Agent loops: tighten max_steps and detect repeated tool calls.
• Wrong tool calls: improve tool descriptions and schemas.
• Context overflow: summarize and trim older turns.