Three Categories of Agents

Agents differ by where they run and who they serve:

Local Agents — Run on developer machines

• User-facing, interactive
• Examples: coding, docs, data analysis
• Trust model: user approves actions

Remote Agents — Run on servers, user-facing

• Handle customer/employee interactions
• Examples: chatbots, voice assistants, ticket handlers
• Trust model: pre-configured guardrails

Headless Agents — Run on servers, no user

• Triggered by events, schedules, or other agents
• Examples: CVE scanning, anomaly detection, health checks
• Trust model: fully autonomous with monitoring

Local: AI Coding Agent

The most mature agentic use case:

What it does:

• Reads your entire codebase
• Understands architecture patterns via AGENTS.md
• Writes, tests, and debugs code across multiple files
• Self-corrects when tests fail

Example workflow:

You: "Add pagination to the /api/users endpoint"
Agent:
  1. Reads existing user route and model
  2. Adds page/limit query params
  3. Updates Mongoose query with skip/limit
  4. Adds total count to response headers
  5. Writes tests for pagination edge cases
  6. Runs tests — 1 failure
  7. Fixes the off-by-one error
  8. Tests pass
  9. Commits: "feat: add pagination to users endpoint"

Tools: Claude Code, OpenCode, Cursor Agent Mode

Local: Documentation Agent

Automates the most-skipped development task:

What it does:

• Scans codebase for undocumented functions and APIs
• Generates documentation matching your project's style
• Keeps docs in sync with code changes
• Creates architectural diagrams from code structure

Trigger examples:

• Post-commit hook: "Update docs for changed files"
• Weekly schedule: "Audit documentation completeness"
• PR review: "Generate docs for new public APIs"

Local: Data Analysis Agent

What it does:

• Accepts data files (CSV, JSON, SQL results)
• Asks clarifying questions about the data
• Performs analysis and generates visualizations
• Exports reports in multiple formats

Local agents are the easiest to build and deploy — they run in your terminal and use your existing file system as the "world" they operate in.

Remote: Customer Support Chatbot

The highest-ROI agentic use case for most businesses:

Architecture:

Customer → Chat Widget → Agent → Backend APIs
                           ↓
                    Knowledge Base (RAG)
                           ↓
                    Escalation to Human

What it does:

• Answers common questions from knowledge base (70-80% auto-resolved)
• Looks up order status, account info via API tools
• Escalates complex issues to human agents with full context
• Learns from resolved tickets to improve over time

Key metrics:

• Deflection rate: % of tickets resolved without human
• Customer satisfaction: should be >= human agents
• Average resolution time: typically 80% faster than human
• Cost per ticket: $0.10-0.50 vs. $5-15 for human agents

Remote: Voice Agent

The next frontier in customer interaction:

What it does:

• Answers phone calls with natural conversation
• Understands intent, asks follow-up questions
• Accesses backend systems (CRM, order management)
• Handles appointment scheduling, order status, basic troubleshooting
• Transfers to human for complex issues

Architecture:

Phone → Speech-to-Text → LLM Agent → Text-to-Speech → Phone
              ↕                ↕
         Audio stream    Backend APIs

Remote: Ticket Triage Agent

What it does:

• Monitors incoming support/engineering tickets
• Classifies by priority, category, and team
• Assigns to the right person/team
• Adds context from related past tickets
• Suggests potential solutions based on similar resolved issues

Remote agents handle the high-volume, repetitive work that consumes 60-80% of support team capacity.

Headless: CVE Scanner

Security monitoring that never sleeps:

What it does:

• Monitors CVE databases for new vulnerabilities
• Cross-references with your dependency list
• Assesses impact based on your architecture (using AGENTS.md)
• Creates prioritized tickets for critical findings
• Suggests patches or mitigations

Workflow:

New CVE published
  → Agent checks: "Does this affect our dependencies?"
  → YES: "How critical is this for our specific usage?"
  → CRITICAL: Create P0 ticket, notify security team, suggest fix
  → LOW: Create backlog ticket with analysis

Headless: Anomaly Detection Agent

What it does:

• Monitors application metrics (latency, error rates, resource usage)
• Detects anomalies using statistical analysis + LLM reasoning
• Investigates root cause by correlating logs, metrics, and recent deployments
• Creates incident reports with probable cause and remediation steps

Headless: Health Check Agent

Proactive system monitoring:

What it does:

• Runs scheduled health checks across your infrastructure
• Tests API endpoints, database connections, third-party integrations
• Compares current performance to baselines
• Predicts potential failures before they happen
• Generates weekly health reports for stakeholders

Example schedule:

Every 5 minutes:  Check critical API endpoints
Every hour:       Test database query performance
Every day:        Full integration test suite
Every week:       Generate health summary report
On alert:         Investigate and report root cause

Headless agents provide the highest ROI for operations teams — they work 24/7, never miss an alert, and investigate issues faster than on-call engineers.

Choosing Your First Agent

Start with the highest-impact, lowest-risk use case:

Use Case	Impact	Complexity	Risk	Start Here?
Coding agent	High	Low	Low	Yes
Doc generation	Medium	Low	Low	Yes
Support chatbot	Very High	Medium	Medium	After coding
CVE scanner	High	Medium	Low	After coding
Voice agent	Very High	High	High	Later
Anomaly detection	High	High	Medium	Later

Recommendation: Start with a coding agent (Claude Code or OpenCode). You'll learn agentic patterns hands-on, with zero risk to production systems.

---quiz question: What is the key difference between a "local" and a "headless" agent? options:

• { text: "Local agents are faster", correct: false }
• { text: "Local agents run on your machine with user interaction; headless agents run on servers triggered by events with no user", correct: true }
• { text: "Headless agents are more intelligent", correct: false } feedback: Local agents run interactively on developer machines with the user reviewing and approving actions. Headless agents run autonomously on servers, triggered by events, schedules, or other systems — with no human in the loop.

---quiz question: Why do customer support chatbots have the highest ROI for most businesses? options:

• { text: "Because they're the cheapest to build", correct: false }
• { text: "They auto-resolve 70-80% of tickets at $0.10-0.50 each vs. $5-15 for human agents", correct: true }
• { text: "Because customers prefer talking to AI", correct: false } feedback: Support chatbots handle the high-volume, repetitive work that consumes most of a support team's time. At 70-80% auto-resolution and 10-30x lower cost per ticket, the ROI is immediate and measurable.

---quiz question: What should be your first agentic AI project? options:

• { text: "A customer-facing voice agent", correct: false }
• { text: "A full multi-agent orchestration system", correct: false }
• { text: "A coding agent — low risk, high learning value, immediate benefit", correct: true } feedback: Start with a coding agent because it has zero production risk (runs on your machine), teaches you agentic patterns hands-on, and provides immediate productivity benefits.