AI agents in production are systems that use foundation models as decision-making engines, call tools to take actions, and work toward goals across multiple steps. The pattern moves the model from text generation to actual work in real systems. Real examples reveal what kinds of agent designs actually ship and produce value, what fails despite plausible architectures, and how the operational realities differ from the marketing.
The shape of production AI agents in 2026 is more constrained than the abstract concept might suggest. Successful agents are narrow rather than general. They have well-designed tool sets rather than generic capabilities. They operate within bounded scopes rather than open-ended autonomy. They keep humans in the loop for hard cases rather than trying to handle everything. The teams that ship working agents discovered these constraints; the teams that aim for broad autonomy mostly produce demos.
The current production landscape includes coding agents (the most mature category), customer support agents (deployed at significant scale), research and analysis agents (growing fast), and operations agents (emerging across enterprises). Each category has companies with shipping products, observable patterns, and lessons learned. Beyond these mature categories, agentic systems exist but with more variable reliability.
The architecture that works has consistent patterns across categories. A control loop where the model decides what to do next, the system executes the action, and the result feeds back into the model. Tool use with clearly defined functions the agent can call. Memory for context within a task and sometimes across tasks. Budget controls that prevent runaway iterations. Observability that captures the full trace of agent decisions. Safety controls for irreversible actions. The patterns are the same whether the agent is a coding assistant, a support bot, or an operations workflow.
This page surveys real implementations across the major use case categories. Specific company claims should be verified through original sources before being used as benchmarks; the AI agent space evolves quickly enough that yesterday's marketing claims may not match today's reality. The patterns and lessons translate even when specific numbers do not.
Cursor is among the most widely-adopted coding agents. The product reads codebases, edits multiple files, runs commands, and iterates with developer feedback. The integration with the developer's existing IDE workflow reduces friction. Engineers use it for daily work rather than as a separate experimental tool.
The pattern that makes Cursor work: tight feedback loops with the developer (the engineer is always nearby to redirect), version control as a safety net (mistakes can be reverted), and integration with actual workflows (not a separate environment that engineers have to switch into). The agent assists rather than replaces; the engineer remains the decision maker.
Claude Code provides a similar pattern through a CLI interface. Engineers run Claude Code in their terminal, point it at tasks, and review the changes it makes. The terminal-based interface fits engineering workflows where developers already spend time on the command line. The Anthropic Agent SDK formalizes the patterns that work for this kind of agent.
GitHub Copilot Workspace extends single-file completion to multi-file workflows. The integration with GitHub issues and pull requests fits teams already using GitHub heavily. The workflow becomes: file an issue, the agent proposes a solution, the developer reviews and merges. The integration reduces context switching.
Cognition's Devin demonstrated longer-horizon coding agents with autonomous task completion over hours. The reliability varies by task complexity. Simple well-defined tasks complete reliably. Complex tasks with ambiguous requirements often need course correction. The launch hype suggested broader capability than the production reality has shown.
Many companies build custom internal coding tools combining off-the-shelf foundation models with company-specific knowledge: internal libraries, coding standards, codebase patterns, deployment processes. The customization makes tools more useful for the specific company than generic alternatives. The pattern is common at larger engineering organizations.
Intercom Fin is widely deployed across thousands of customer companies. The agent retrieves from each customer's knowledge base, generates responses, and takes structured actions like refunds, account updates, and information lookups. Resolution rates for routine queries often exceed 50%. Out-of-scope queries escalate to human agents with full context.
The pattern that works: deep integration with customer-specific data (each customer's knowledge base, customer records, support history), structured tool use for actions (not just text generation), and clean escalation to humans when out of scope. The integration depth distinguishes useful production agents from generic chatbots that cannot resolve much.
Decagon offers similar capabilities with deep CRM integration. Salesforce, Zendesk, and other enterprise systems become tool sets the agent uses to resolve customer issues. Decagon agents read customer history, understand specific account state, and take actions through CRM APIs. The depth produces meaningfully better outcomes than chatbots without context.
Klarna's published numbers on AI-driven support handled work equivalent to hundreds of customer service agents. The case illustrates what is possible at scale, though the headline numbers have been debated and the long-term impact has been disputed. Even with the debates, the case shows that AI agents can handle large support volumes when implemented well.
Many companies build custom support agents using foundation model APIs and internal knowledge bases. The custom build pattern works when companies have specific data integration needs that vendor products do not address well. The trade-off is engineering investment versus the convenience of vendor solutions.
The honest pattern in customer support agents: they handle the routine cases that volume-multiplied are most of the work. Novel cases, sensitive cases, and unusual cases still escalate to humans. The combination of agent and human is faster and more consistent than human-only support, but the agent does not replace the human entirely.
ChatGPT Deep Research browses the web, reads documents, and synthesizes findings. Companies use it for competitive intelligence, market research, due diligence, and similar tasks. Output quality depends heavily on source availability for the topic; common topics produce good results, niche topics produce variable quality.
Claude with research capabilities and Anthropic's Computer Use feature lets the model interact with web interfaces directly. The agent can click, scroll, and fill forms in addition to reading text. The capability is more flexible than pure text-based research but also slower and more variable.
Gemini Deep Research provides similar capabilities with strong integration into Google's broader knowledge infrastructure. The integration with Google Search means access to information that other research agents may not reach as easily.
Vertical research products target specific industries. Harvey for legal research and document analysis. Hippocratic AI for healthcare. Paxton for accounting and finance. The vertical specialization adds domain-specific data sources and workflows that general-purpose research agents do not provide.
The use cases that work include competitive intelligence (gathering information across competitors' websites and filings), market research (synthesizing findings from many sources), due diligence (researching potential acquisitions or partnerships), and regulatory research (compiling current rules across jurisdictions). The pattern works when the research task can be specified clearly enough that the agent knows what good output looks like.
Finance reconciliation agents match transactions across systems, identify discrepancies, generate summaries for human review, and handle routine cases automatically. The pattern fits finance operations because the work involves significant volumes of structured data with clear correctness criteria. Companies report meaningful productivity gains.
IT helpdesk agents triage tickets, suggest solutions from knowledge bases, and resolve routine issues like password resets and access requests. The agent reduces routine load on IT staff who can focus on more complex issues. Companies report significant ticket deflection rates for well-implemented agents.
HR onboarding agents handle common questions about policies, benefits, processes. The agent provides consistent answers and frees HR staff for more complex employee issues. The use case fits because HR has significant routine question volume with clear answers in policy documents.
Sales operations agents handle prospect research, CRM updates, meeting preparation, and follow-up tracking. The agent automates the operational work that traditionally consumed significant salesperson time. Sales staff focus on conversations; the agent handles the supporting work.
Engineering operations agents assist with incident response (suggesting causes from logs), capacity planning, security monitoring, and infrastructure management. The patterns extend traditional DevOps and SRE practices with AI assistance.
The successful operations agents share characteristics: well-defined inputs, clear success criteria, integration with the systems where the work actually happens, and human oversight for unusual cases. The agent automates the routine; humans handle the exceptions.
Single agent with a focused tool set. Most production agents use this architecture. The agent has a clear scope, a small number of well-designed tools, and operates within explicit budgets. Simpler than multi-agent designs and usually produces better results.
Orchestrator-worker pattern when needed. One main agent delegates specific subtasks to specialized helpers. The orchestrator makes the high-level decisions; the workers handle specific operations. Used when the workflow has clearly different subtasks that benefit from specialization.
Tool design as critical engineering work. The tool definitions are the contract between the agent and the world. Vague tool descriptions confuse the agent. Clear single-purpose tools produce reliable behavior. The investment in tool design pays back many times over in agent quality.
Budget controls as standard practice. Maximum step count, maximum total tokens, maximum wall-clock time. Hit any limit and the agent stops. The controls prevent the rare pathological case from producing expensive bills or hung tasks.
Observability through full trace capture. Every model call, every tool call, every result. Tools like LangSmith, Langfuse, and Braintrust provide trace storage. When something goes wrong, the team can walk the trace to find what happened.
Safety boundaries layered into the design. Permission gates for irreversible actions. Sandboxing for code execution. Audit logs for everything. The patterns are not exotic; they are basic engineering for systems that take actions on behalf of users.
Vague tool descriptions confuse the agent. The model picks the wrong tool because the description does not clearly indicate when each tool applies. The fix is investing in tool documentation as if writing API documentation for human consumption.
No budget controls produce runaway loops. The agent gets stuck retrying the same approach. Token costs accumulate. Wall-clock time grows. Without limits, the worst case is expensive and embarrassing. The fix is setting limits at design time, not after the first incident.
Missing observability prevents debugging. Failures happen but the team has no visibility into what went wrong. Every investigation becomes archaeology. The fix is instrumenting the agent loop from launch.
Unbounded autonomy produces expensive mistakes. The agent takes irreversible actions without human review. The actions sometimes turn out to be wrong. The fix is permission gates for actions that cannot be easily undone.
Skipped evaluation lets quality drift. The team ships and assumes everything is fine. Production traffic exposes failure modes the team never considered. The fix is building evaluation harnesses before launch and running them on every change.
Coding agents because tests provide fast accurate feedback signals. The agent makes changes, runs tests, sees pass or fail, adjusts. The feedback loop is tight and the success criteria are objective. Other categories work but with less reliable feedback. Customer support agents are second most reliable in well-implemented cases. The reliability comes from access to current knowledge bases, structured tool use, and clean escalation patterns. Operations agents work for narrow well-defined workflows but are less reliable for broad operations work.
Seconds to minutes for simple interactive tasks. Minutes to tens of minutes for complex tasks with many steps. Hours for very complex tasks that span many interactions. The latency depends on number of steps, model used, and tool call latency. For interactive use cases where users wait for results, latency matters significantly. Streaming intermediate progress to the user makes longer tasks feel faster. For async use cases, longer latency is acceptable as long as the result eventually arrives.
Cents to dollars per task depending on complexity. Simple tasks completing in three steps with moderate context cost a few cents. Complex tasks with many steps and large context cost a few dollars. Aggregate costs over many tasks can reach meaningful numbers. Cost optimization patterns include using smaller models for simpler decisions, caching common results, minimizing context bloat, and capping iteration counts. The teams that monitor cost from launch tend to control it. The teams that do not get surprised.
Through end-to-end task completion rates plus inspection of decision traces. The high-level metric is whether the agent achieved the goal. The deeper inspection examines whether it took a reasonable path. Tools like LangSmith and Braintrust support trace-level evaluation. Evaluation requires representative tasks with expected outcomes. Building this set takes effort but pays back significantly. Without an evaluation harness, changes to the agent are guesses; with one, changes are measured improvements. What about safety? Permission gates for irreversible actions are standard. Sandboxing for code execution. Audit logs for every action. Rate limits on dangerous operations. These are basic engineering for any system that takes actions on behalf of users, not optional features. The teams that include safety from the start ship more reliable systems. The teams that add safety after problems emerge usually do so after expensive mistakes.
Unbounded loops, wrong tool selection, hallucinations, edge cases the eval set missed, cost spikes from runaway iterations. The defenses against these are well-understood: budget limits, validation, evaluation, broader testing, monitoring. Production agents that include these defenses fail less catastrophically than those that do not. The fail modes are predictable enough that prevention is straightforward; the failures usually happen because teams did not implement the standard defenses.
Used selectively for specific patterns: research workflows with parallel exploration, code review with separate writer and critic, operations workflows with domain-specific helpers. Most production agent systems are single-agent or shallow orchestrator-worker rather than deep multi-agent hierarchies. Single-agent systems with good tools often outperform multi-agent setups on the same task. The coordination overhead of multi-agent systems is real. The error compounding is real. Multi-agent should be the answer when the workflow clearly demands it, not the default.
On foundation models with frameworks (LangGraph, AutoGen, the Anthropic Agent SDK, the OpenAI Agents SDK) or with custom orchestration written directly against foundation model APIs. The choice depends on workflow complexity and team familiarity. For simple narrow agents, custom code is often the right choice. The basic loop is simple enough that frameworks add complexity without proportional benefit. For complex agents with multi-agent coordination or persistent state, frameworks earn their cost.
Frontier models from Anthropic (Claude Opus, Claude Sonnet), OpenAI (GPT-5 family), and Google (Gemini 2.5) all produce strong results. They differ in tool use precision, reasoning style, and instruction following. Production teams test on their actual workload rather than picking based on benchmarks. Smaller faster models work for simpler tasks. Production systems often route easy tasks to smaller models and reserve frontier models for complex tasks. The routing pattern produces better cost-quality outcomes than using frontier models for everything.
More vertical agents specialized for specific industries. Better tool ecosystems with computer-use and broader integration. Improved operational practices as the field matures. Gradually expanding scope as model capability and infrastructure improve. The bigger trend is agentic patterns becoming embedded in many products rather than appearing as distinct AI agents. The way mobile became infrastructure for applications, agentic AI is becoming infrastructure for applications. By 2027 or 2028, expect agentic capabilities to be a feature of many tools rather than a separate category.
