What Is an AI Agent?

What Is an AI Agent?

An AI agent is a software system that wraps a large language model with tools, memory, and a control loop so it can pursue a goal across multiple steps. The model decides what to do next; the agent runtime executes it — call a tool, query a vector store, hand off to another agent — feeds the result back, and asks the model again. The loop continues until the goal is met or a stop condition fires. In a FutureAGI trace, an agent appears as a parent span with nested LLM spans, tool spans, and handoff spans that together form a trajectory.

Why AI agents matter in production LLM and agent systems

A single LLM call has one failure surface: the output text. An agent has many. A planner step can pick the wrong tool. A tool can time out or return malformed JSON. A retriever can pull stale context. A handoff can drop critical state. Each of those errors compounds — step three is only as good as steps one and two, and a wrong tool selection at step one usually means the next four steps are wasted tokens and dollars.

The pain is felt unevenly. A backend engineer sees runaway cost on a request that should have cost $0.02 and cost $4. An SRE sees p99 latency double when one tool starts throttling. A product lead watches an agent confidently complete the wrong task — book the wrong flight, file the wrong ticket — because no one checked goal alignment, only output fluency. End users see an agent that is sometimes brilliant and sometimes silently broken.

In 2026-era stacks built on OpenAI Agents SDK, LangGraph, CrewAI, or AutoGen, agents are no longer an experiment — they ship inside customer-facing flows. That changes the engineering contract. You need step-level evaluation, not just final-answer evaluation. You need traces that show the trajectory, not just the response. And you need regression evals that cover the whole loop, because changing one prompt at step two breaks step five in ways no unit test will catch.

How FutureAGI handles AI agents

FutureAGI’s approach is to evaluate the agent at three resolutions and tie all of them to the same trajectory. At the trace level, traceAI integrations such as openai-agents, langgraph, crewai, and autogen emit OpenTelemetry spans for every agent step — planner, tool call, handoff, observation. Each span carries agent.trajectory.step, the agent name, the tool name, and the model used. At the step level, the ToolSelectionAccuracy evaluator scores whether the agent picked the right tool given the input, and ReasoningQuality scores whether the chain-of-thought is logically valid given the observations. At the goal level, TaskCompletion returns a 0–1 score for whether the user’s original goal was reached, while GoalProgress and StepEfficiency quantify partial progress and wasted steps.

Concretely: an engineering team shipping a support agent on the OpenAI Agents SDK instruments it with OpenAIAgentsInstrumentor, samples production traces into an eval cohort, runs TaskCompletion and ToolSelectionAccuracy on each, and dashboards eval-fail-rate-by-cohort. When fail rate spikes after a model swap from gpt-4o to gpt-4o-mini, the trace view points to a planner step where the smaller model started picking the wrong tool 12% of the time. FutureAGI surfaces that one step inside a trajectory of fifteen — without it, you would only see “agent fail rate up” and have nowhere to look.

How to measure or detect AI agents

Pick signals that match the agent’s surface — single-turn agents do not need trajectory metrics, but anything multi-step does:

• TaskCompletion: returns 0–1 plus a reason for whether the agent finished the user’s actual goal, not just produced output.
• GoalProgress: returns partial-progress credit across the trajectory — useful when binary success is too coarse.
• TrajectoryScore: aggregates step-level scores into a single trajectory rating; pairs well with StepEfficiency.
• ToolSelectionAccuracy: returns whether each tool call was the correct choice given the state at that step.
• agent.trajectory.step (OTel attribute): the canonical span attribute on every agent step — filter your dashboard by it.
• eval-fail-rate-by-cohort (dashboard signal): the percentage of agent traces that fail TaskCompletion, sliced by route, model, or user cohort.

Minimal Python:

from fi.evals import TaskCompletion, ToolSelectionAccuracy

task = TaskCompletion()
tool = ToolSelectionAccuracy()

result = task.evaluate(
    input="Refund order 12345",
    trajectory=trace_spans,
)
print(result.score, result.reason)

Common mistakes

• Treating an agent as a single LLM call with extra steps. It isn’t — the loop, the tools, and the memory are first-class failure surfaces. Evaluate each, not just the final answer.
• Only running end-to-end success evals. A 70% TaskCompletion rate hides whether the failures are tool selection, planning, or memory — break it down by step.
• Letting the agent run unbounded. No max-iteration cap turns a single bug into a runaway-cost incident; cap turn count and watch infinite-loop metrics.
• Ignoring tool latency in the agent budget. Agents amplify latency: ten tool calls at p99 = 200ms each is a 2-second floor before the model even thinks.
• Using FutureAGI traces without step-level evaluators. Traces alone show what happened; evaluators tell you whether it was right.