AI agents & autonomous workflows

AI agents are software systems that can independently reason, plan, and execute multi-step tasks — browsing the web, calling APIs, writing and running code, and making decisions based on results. They go beyond simple chatbots to handle complex workflows that previously required human coordination.

What AI agents are

A chatbot answers questions. An agent completes tasks.

When you ask a chatbot “What’s the weather in London?”, it gives you an answer. When you ask an agent “Book me a flight to London next Thursday, the cheapest option with a window seat, and add it to my calendar,” it reasons through the steps, calls multiple APIs, makes decisions, and executes the task end-to-end.

Agents use large language models as their “brain” but extend them with tools: web browsing, code execution, API calls, file manipulation, and database access. The LLM decides which tools to use, in what order, and how to handle errors — mimicking the reasoning process a human would follow.

According to McKinsey’s 2025 State of AI report, 62% of organisations are experimenting with AI agents, but fewer than 10% have scaled them in any single function. The technology is maturing rapidly — 2026 is widely expected to be the year agents move from experiments to production.

How to build AI agents for business automation

Step 1: Identify the right use case

Good agent use cases share these characteristics:

• Multi-step — The task requires multiple actions in sequence, not just a single answer
• Rule-based with exceptions — The process follows a general pattern but requires judgment for edge cases
• Tool-intensive — The task involves interacting with multiple systems (APIs, databases, websites)
• Repetitive but variable — The same type of task repeats frequently, but each instance has unique details

Examples of strong agent use cases:

• Research a company and generate a sales brief from public data
• Monitor competitor pricing and generate alerts when changes occur
• Process incoming invoices: extract data, match to POs, flag discrepancies
• Triage customer support tickets and draft initial responses
• Generate weekly reports by querying multiple data sources

Step 2: Choose your agent framework

LangGraph — Built by the LangChain team, LangGraph models agent workflows as graphs with nodes (actions) and edges (decision paths). It supports complex, multi-step workflows with cycles, human-in-the-loop checkpoints, and persistent state. Best for production-grade agents that need reliability and observability.

CrewAI — A framework for building multi-agent systems where specialised agents collaborate. You define agents with specific roles (researcher, analyst, writer), give them tools, and CrewAI orchestrates their collaboration. Best for tasks that naturally decompose into specialised roles.

Microsoft AutoGen — Microsoft’s multi-agent framework that supports conversational agent patterns. Agents can discuss, debate, and collaborate to solve problems. Strong integration with Azure services.

Claude Code — While primarily a coding agent, Claude Code demonstrates what autonomous agents look like in practice. It navigates codebases, makes multi-file changes, runs tests, and iterates — all with minimal human guidance.

OpenAI — OpenAI’s Assistants API provides a simpler agent framework with built-in tools (code interpreter, file search, function calling). Good for straightforward single-agent use cases.

Step 3: Design the agent workflow

A well-designed agent workflow includes:

1. Goal definition — What should the agent accomplish? Be specific: “Generate a competitive analysis report for [company name] covering pricing, product features, and recent news”
2. Tool access — What APIs, databases, and services does the agent need? Define each tool with clear input/output specifications
3. Decision points — Where might the agent need to choose between different approaches? Define the criteria for each decision
4. Error handling — What should happen when an API call fails, data is missing, or the result doesn’t make sense? Build in retries, fallbacks, and escalation to humans
5. Human-in-the-loop checkpoints — For high-stakes decisions or outputs, insert approval points where a human reviews before the agent continues
6. Output format — Define exactly what the agent should produce: a report, a database entry, an email, a Slack message

Step 4: Build and test

Development workflow for a production agent:

1. Start with a simple prototype using a single LLM and basic tools
2. Test with 20–30 real examples, noting where the agent fails or produces poor results
3. Add guardrails: input validation, output verification, safety checks
4. Implement observability: log every step, decision, and tool call for debugging
5. Add human review for the first 100 production runs
6. Gradually reduce human oversight as confidence grows

Langfuse and Helicone provide observability for agent workflows — tracking every LLM call, tool use, and decision point.

Step 5: Deploy and monitor

Production agents need:

• Rate limiting — Prevent runaway agents from making unlimited API calls
• Cost controls — Set budget limits per agent run (LLM API calls cost money)
• Timeout handling — Kill agents that run too long
• Audit logging — Record every action for compliance and debugging
• Alerting — Notify humans when agents encounter errors or unexpected situations
• Rollback capability — Ability to undo agent actions when something goes wrong

Real examples

Research agent

A consulting firm built a research agent that:

1. Takes a company name as input
2. Searches the web for recent news, press releases, and financial data
3. Visits the company’s website and extracts key information
4. Pulls data from LinkedIn (company size, recent hires, job postings)
5. Generates a 2-page briefing document with company overview, recent developments, competitive position, and potential opportunities

Time to generate a briefing: 3 minutes (vs. 2 hours of manual research). Quality: comparable to junior analyst work, with senior analysts spending 15 minutes refining rather than 2 hours researching.

Multi-agent content pipeline

A media company built a CrewAI-based content pipeline with three collaborating agents:

• Researcher agent — Searches news sources and databases for trending topics, collects data and statistics
• Writer agent — Takes research output and drafts an article following the publication’s style guide
• Editor agent — Reviews the draft for accuracy, tone, and completeness; suggests improvements

The three agents collaborate iteratively — the editor sends feedback to the writer, who revises and resubmits. A human editor reviews the final output before publication.

Result: first-draft quality improved by 40% compared to a single LLM prompt, and the research was more thorough because the researcher agent systematically checked multiple sources.

DevOps monitoring agent

An engineering team built an agent that monitors their production systems:

1. Receives alerts from their monitoring stack (Datadog, PagerDuty)
2. Investigates the alert: checks logs, queries metrics, examines recent deployments
3. Diagnoses the likely cause based on patterns it’s seen before
4. For known issues, executes the documented remediation steps automatically
5. For unknown issues, compiles a diagnostic report and pages the on-call engineer with context

The agent handles 30% of production alerts autonomously (known issues with documented fixes) and reduces diagnosis time for escalated alerts by 60% (because the on-call engineer receives a pre-compiled investigation rather than a raw alert).

Customer onboarding agent

A SaaS company built an onboarding agent that:

1. Receives a new customer signup event
2. Analyses the customer’s website, industry, and company size
3. Configures their account with recommended settings based on similar customers
4. Generates a personalised onboarding guide
5. Sends a welcome email with the guide and next steps
6. Schedules check-in touchpoints at day 3, 7, and 14

Previously, onboarding was handled by a customer success manager who spent 45 minutes per new account. The agent handles the routine setup, and the CSM focuses on relationship-building and custom configuration requests.

Tool comparison

Feature	LangGraph	CrewAI	AutoGen	OpenAI Assistants
Architecture	Graph-based workflows	Multi-agent roles	Conversational agents	Single-agent with tools
Complexity handling	High (cycles, branching)	Medium (role-based)	Medium (conversation)	Low-medium
Human-in-the-loop	Built-in checkpoints	Configurable	Configurable	Limited
Observability	Via LangSmith/Langfuse	Basic logging	Basic logging	Dashboard
Learning curve	Steep	Moderate	Moderate	Low
Best for	Complex production agents	Team-based tasks	Collaborative reasoning	Simple agent use cases

Common questions

Are AI agents reliable enough for production?

For well-defined, bounded tasks with human oversight — yes. For open-ended, high-stakes tasks — not yet. The key is designing agents with clear boundaries, error handling, and human checkpoints. Start with low-stakes use cases and expand as you build confidence.

How much do agents cost to run?

Each agent run involves multiple LLM API calls. A simple agent might make 5–10 calls per task ($0.05–$0.50). A complex research agent might make 30–50 calls ($1–$5). At scale, costs are significant but typically far less than the human time they replace. Budget $100–$500/month for moderate agent usage.

What’s the difference between agents and automation?

Automation follows predefined rules: if X, then Y. Agents reason about novel situations: given goal Z, figure out the best approach, handle unexpected obstacles, and adapt the plan as needed. Automation is more reliable for fixed processes; agents handle variability better.

Can agents access our internal systems?

Yes, with proper security controls. Agents access systems via API keys, OAuth tokens, or service accounts — the same way any software integration works. Implement least-privilege access (agents only get access to what they need) and audit logging for all agent actions.

When should we use agents vs. simple LLM calls?

Use a simple LLM call when: the task is a single step (summarise this text, answer this question, generate this email). Use an agent when: the task requires multiple steps, tool access, decision-making, or iteration based on intermediate results.

Tools referenced in this guide

• LangGraph — Graph-based agent framework for complex workflows
• CrewAI — Multi-agent collaboration framework
• Microsoft AutoGen — Conversational multi-agent framework
• OpenAI — Assistants API for single-agent applications
• Claude Code — Autonomous coding agent
• Langfuse — Agent observability and monitoring
• Helicone — LLM cost and performance tracking