Chatbot workflow:
User: "Book me a flight to London"
Chatbot: "I'd recommend British Airways or 
         Lufthansa. You can book at ba.com 
         or lufthansa.com."
Result: User does the work

Agent workflow:
User: "Book me a flight to London for the 
      conference next week"
Agent: "I've booked you on BA287, Tuesday 
       departure 09:15, arriving 10:30. 
       I've added it to your calendar, 
       sent you confirmation email, and 
       updated the travel expense system.
       Total: €450, within budget."
Result: Work is done

Chatbots: Provide information
├── Answer questions
├── Retrieve data
├── Make recommendations
└── Output: Text responses

AI Agents: Take actions
├── Execute tasks
├── Integrate with systems
├── Make decisions
├── Chain multiple operations
└── Output: Real-world changes

Information tasks:
├── Search and synthesize data
├── Generate reports
├── Analyze documents
├── Answer complex questions
└── Monitor for changes

Action tasks:
├── Book appointments and reservations
├── Send emails and messages
├── Update records in databases
├── Process orders and payments
├── Create tickets and tasks
├── Generate documents
└── Trigger workflows

Decision tasks:
├── Route requests to right department
├── Prioritize based on rules
├── Approve within defined limits
├── Escalate when needed
└── Learn from outcomes

┌─────────────────────────────────────────┐
│           AI AGENT ARCHITECTURE         │
└─────────────────────────────────────────┘

1. BRAIN (LLM)
   ├── Understands user intent
   ├── Reasons about tasks
   ├── Plans multi-step actions
   ├── Decides which tools to use
   └── Generates responses

2. MEMORY
   ├── Conversation history
   ├── User context and preferences
   ├── Task state and progress
   ├── Learned patterns
   └── Long-term knowledge

3. TOOLS
   ├── API integrations
   ├── Database connections
   ├── External services
   ├── File operations
   └── Custom functions

4. ORCHESTRATION
   ├── Task decomposition
   ├── Tool selection
   ├── Error handling
   ├── State management
   └── Safety guardrails

5. INTERFACES
   ├── Chat (text, voice)
   ├── API endpoints
   ├── Scheduled triggers
   ├── Event webhooks
   └── Admin dashboard

ReAct: Reasoning + Acting

Traditional chatbot:
Input → Response

ReAct agent:
Input → Think → Act → Observe → Think → Act → ... → Response

Example:
User: "What's our best-selling product this month?"

Agent thought: "I need to query the sales database 
for this month's sales by product."

Agent action: Call sales_query tool
Parameters: {period: "current_month", sort: "revenue_desc", limit: 1}

Agent observation: Result = {product: "Widget Pro", 
units: 2,340, revenue: €234,000}

Agent thought: "I have the answer. User might also 
want context, so I'll add comparison to last month."

Agent action: Call sales_query tool  
Parameters: {period: "last_month", product: "Widget Pro"}

Agent observation: Result = {units: 1,890, revenue: €189,000}

Agent response: "Widget Pro is your best seller this 
month with 2,340 units sold (€234,000 revenue). 
That's a 24% increase from last month's 1,890 units."

Tool definition structure:
{
  "name": "create_calendar_event",
  "description": "Creates a new event on the user's 
                  Google Calendar",
  "parameters": {
    "type": "object",
    "properties": {
      "title": {
        "type": "string",
        "description": "Event title"
      },
      "start_time": {
        "type": "string",
        "description": "Start time in ISO format"
      },
      "end_time": {
        "type": "string",
        "description": "End time in ISO format"
      },
      "attendees": {
        "type": "array",
        "items": {"type": "string"},
        "description": "List of attendee emails"
      }
    },
    "required": ["title", "start_time", "end_time"]
  }
}

Tool implementation:
async function create_calendar_event(params) {
  const { title, start_time, end_time, attendees } = params;
  
  const event = await googleCalendar.events.insert({
    calendarId: 'primary',
    requestBody: {
      summary: title,
      start: { dateTime: start_time },
      end: { dateTime: end_time },
      attendees: attendees?.map(email => ({ email }))
    }
  });
  
  return {
    success: true,
    event_id: event.id,
    link: event.htmlLink
  };
}

Good agent use cases:
├── Repetitive tasks (high volume, consistent)
├── Multi-step workflows (3+ steps)
├── System integrations needed
├── Decision rules can be codified
├── Clear success criteria
└── Moderate complexity (not trivial, not chaotic)

Questions to answer:
1. What task should the agent perform?
2. What systems does it need to access?
3. What decisions does it need to make?
4. What are the failure modes?
5. When should it escalate to humans?

Use case: Process incoming purchase orders

Inputs:
├── Order emails from customers
├── Customer database
├── Inventory system
├── Pricing rules

Actions:
├── Extract order details from email
├── Validate customer and credit
├── Check inventory availability
├── Apply appropriate pricing
├── Create order in ERP
├── Send confirmation to customer
├── Alert sales rep if issues

Success criteria:
├── Orders processed in <5 minutes
├── 95% straight-through processing
├── Zero pricing errors
├── Customer confirmation sent
└── Proper escalation when needed

For each required action:

1. Define the tool interface
   ├── Name and description
   ├── Input parameters
   ├── Output format
   └── Error conditions

2. Implement the tool
   ├── API connections
   ├── Authentication
   ├── Data transformation
   └── Error handling

3. Test thoroughly
   ├── Happy path
   ├── Edge cases
   ├── Error scenarios
   └── Performance

Data retrieval:
├── Database queries
├── API calls
├── Document search
├── File reading
└── Web scraping

Data creation:
├── Record creation
├── File generation
├── Email sending
├── Message posting
└── Notification triggering

External services:
├── Calendar operations
├── Payment processing
├── Shipping services
├── Communication platforms
└── Third-party SaaS

Internal systems:
├── ERP/CRM updates
├── Ticket creation
├── Workflow triggers
├── Approval requests
└── Audit logging

Agent system prompt structure:

IDENTITY
You are [Agent Name], an AI assistant that helps 
with [specific domain]. You work for [Company].

CAPABILITIES
You have access to these tools:
- [Tool 1]: [description]
- [Tool 2]: [description]
...

GUIDELINES
1. Always verify customer identity before 
   accessing account information.
2. For orders over €10,000, require manager 
   approval before processing.
3. If inventory is insufficient, offer 
   alternatives before backorder.
...

ESCALATION
Escalate to human when:
- Customer expresses frustration
- Request outside your capabilities
- System errors persist
- Unusual patterns detected

Memory types:

Short-term (conversation):
├── Current conversation messages
├── Tool call results
├── Task progress
└── Cleared on conversation end

Long-term (persistent):
├── Customer preferences
├── Previous interactions summary
├── Learned patterns
└── Stored in database

Context window management:
├── Summarize older messages
├── Keep recent messages verbatim
├── Prioritize relevant context
└── Maintain key facts

Functional testing:
□ All tools work correctly
□ Multi-step workflows complete
□ Error handling is graceful
□ Escalation triggers work
□ Edge cases handled

Safety testing:
□ Cannot perform unauthorized actions
□ Respects permission boundaries
□ Handles adversarial inputs
□ Rate limiting works
□ Audit logging captures actions

Performance testing:
□ Response time acceptable
□ Handles concurrent requests
□ Scales under load
□ Cost per interaction tracked

Implementation requirements:

Action verification:
├── Confirm destructive actions
├── Double-check large values
├── Validate critical parameters
└── Human-in-loop for high stakes

Rate limiting:
├── Max actions per minute
├── Max cost per session
├── Cool-down periods
└── Alert on unusual patterns

Permission model:
├── Role-based access
├── Action-level permissions
├── Data-level restrictions
└── Audit all actions

Phased deployment:

Phase 1: Shadow mode
├── Agent processes alongside humans
├── Results compared, not used
├── Measure accuracy and safety
└── Duration: 1 week

Phase 2: Assisted mode
├── Agent proposes actions
├── Human reviews and approves
├── Learn from corrections
└── Duration: 1-2 weeks

Phase 3: Supervised autonomy
├── Agent acts independently
├── Spot-check sampling
├── Exception handling in place
└── Duration: 2-4 weeks

Phase 4: Full autonomy
├── Agent operates independently
├── Monitoring and alerting
├── Periodic reviews
└── Ongoing

Tool: CRM customer lookup

Implementation:
async function lookup_customer(params) {
  const { email, phone, company } = params;
  
  // Build query
  const query = new URLSearchParams();
  if (email) query.append('email', email);
  if (phone) query.append('phone', phone);
  if (company) query.append('company', company);
  
  // Call CRM API
  const response = await fetch(
    `${CRM_BASE_URL}/customers/search?${query}`,
    {
      headers: {
        'Authorization': `Bearer ${CRM_TOKEN}`,
        'Content-Type': 'application/json'
      }
    }
  );
  
  if (!response.ok) {
    throw new Error(`CRM lookup failed: ${response.status}`);
  }
  
  const customers = await response.json();
  
  // Return formatted result
  return {
    found: customers.length > 0,
    count: customers.length,
    customers: customers.map(c => ({
      id: c.id,
      name: c.name,
      email: c.email,
      status: c.account_status,
      tier: c.customer_tier
    }))
  };
}

Tool: Inventory check

Implementation:
async function check_inventory(params) {
  const { product_id, warehouse } = params;
  
  const query = `
    SELECT 
      p.product_name,
      i.quantity_available,
      i.quantity_reserved,
      i.reorder_point,
      w.warehouse_name
    FROM inventory i
    JOIN products p ON i.product_id = p.id
    JOIN warehouses w ON i.warehouse_id = w.id
    WHERE p.sku = $1
    ${warehouse ? 'AND w.code = $2' : ''}
  `;
  
  const params = warehouse 
    ? [product_id, warehouse] 
    : [product_id];
  
  const result = await db.query(query, params);
  
  return {
    product: product_id,
    warehouses: result.rows.map(r => ({
      warehouse: r.warehouse_name,
      available: r.quantity_available - r.quantity_reserved,
      reserved: r.quantity_reserved,
      low_stock: r.quantity_available < r.reorder_point
    }))
  };
}

Tool: Initiate approval workflow

Implementation:
async function request_approval(params) {
  const { type, amount, description, requester } = params;
  
  // Determine approver based on rules
  const approver = await getApprover(type, amount);
  
  // Create workflow instance
  const workflow = await workflowEngine.create({
    template: 'approval-request',
    variables: {
      request_type: type,
      amount: amount,
      description: description,
      requester: requester,
      approver: approver
    }
  });
  
  // Send notification
  await notificationService.send({
    to: approver,
    template: 'approval-needed',
    data: {
      type: type,
      amount: formatCurrency(amount),
      requester: requester,
      link: workflow.taskUrl
    }
  });
  
  return {
    workflow_id: workflow.id,
    status: 'pending_approval',
    approver: approver,
    estimated_time: '24 hours'
  };
}

Customer service automation:

Information retrieval:
├── Order status lookup
├── Account information
├── Product specifications
├── Policy explanations
└── FAQ answers

Actions:
├── Update contact information
├── Process simple returns
├── Apply account credits
├── Schedule callbacks
├── Create support tickets
└── Escalate to specialists

Decisions:
├── Route to appropriate department
├── Authorize refunds within limits
├── Identify VIP customers
├── Prioritize urgent issues
└── Detect fraud patterns

Sales process automation:

Lead management:
├── Qualify incoming leads
├── Research prospect companies
├── Prepare meeting briefs
├── Schedule appointments
└── Send follow-up emails

Deal support:
├── Generate proposals
├── Configure products
├── Calculate pricing
├── Check inventory
├── Process orders

Analytics:
├── Pipeline reports
├── Win/loss analysis
├── Forecast updates
├── Competitor tracking
└── Performance metrics

Operational automation:

Scheduling:
├── Resource allocation
├── Shift planning
├── Equipment booking
├── Meeting coordination
└── Maintenance scheduling

Monitoring:
├── System health checks
├── Alert processing
├── Incident creation
├── Escalation handling
└── Status reporting

Processing:
├── Order fulfillment
├── Invoice processing
├── Expense approvals
├── Vendor communications
└── Compliance checks

Monthly benefit = (tasks automated x minutes saved x cost/minute)
                + (errors avoided x cost per error)
                - monthly fee
Payback = setup fee / monthly benefit

1. Single responsibility
   ├── One agent = one domain
   ├── Clear boundaries
   ├── Focused tool set
   └── Easier to maintain

2. Fail safely
   ├── Default to human handoff
   ├── Never lose customer data
   ├── Log all actions
   └── Graceful degradation

3. Be transparent
   ├── Explain actions to users
   ├── Provide audit trails
   ├── Show reasoning when helpful
   └── Admit limitations

4. Continuous improvement
   ├── Monitor performance
   ├── Learn from failures
   ├── Update based on feedback
   └── Expand capabilities gradually

Over-automation:
├── Not every task needs an agent
├── Some things need human judgment
├── Start small, expand carefully
└── Measure before scaling

Under-testing:
├── Edge cases will happen
├── Adversarial inputs exist
├── Systems fail unexpectedly
└── Test extensively before launch

Poor error handling:
├── "Something went wrong" isn't helpful
├── Users need clear next steps
├── Always have fallback path
└── Log details for debugging

Ignoring costs:
├── LLM calls add up
├── Monitor spend closely
├── Optimize prompts
└── Cache where possible

Good fit if:
□ High-volume repetitive tasks
□ Multi-system workflows
□ Clear decision rules
□ Measurable outcomes
□ Integration capability

May not need custom agent if:
□ Low volume (under 100/month)
□ Simple single-step tasks
□ Already well automated
□ Highly variable processes