> ## Documentation Index
> Fetch the complete documentation index at: https://docs.domino.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Agents

> How you build an agentic system in Domino, evaluate it against real data, and ship it to the people who use it.

An agent is a program that uses a Large Language Model (LLM) to decide what actions to take. It plans a sequence of steps toward an objective, executes them using tools and APIs, then reflects on the results and replans if they fall short. It's typically a framework such as LangChain, Pydantic AI, or the OpenAI Agents SDK wrapping orchestration logic around an LLM endpoint, or your own code doing the same.

This section covers how you build one in Domino, evaluate it against real data, and ship it to the people who use it. Domino instruments agents with **traces**, and the same trace data carries through development, evaluation, deployment, and production monitoring.

<Note>
  For AI help writing code inside a Workspace, see [coding assistants](/cloud/platform-capabilities/features/coding-assistants) instead. Those assist you as you work; agents are systems you build and deploy for others to use.
</Note>

## How an agent reaches its users

An agent runs on Domino the way an App does. You deploy it either from the [Experiment Manager](/cloud/platform-capabilities/features/agents/experiment), directly from an evaluated agent version, or from your Project's Apps view using the standard [publish an App](/cloud/platform-capabilities/features/apps/publish-an-app) workflow. Once it's running, it appears alongside Apps under **Deployments** > **Apps & Agents**, where the people you've shared it with can find it and use it in the browser with nothing to install.

Because deployment reuses the App path, agents get the platform's hosting, permissions, and routing without extra setup. Agents also have their own [audit trail](/cloud/platform-capabilities/features/governance/audit-trail) events, covering access granted and revoked, access requests, and changes to an agent's visibility and discoverability.

## How it works in Domino

A trace is a structured record of every LLM call, tool invocation, and decision your agent makes. It captures token usage, latency, and cost. One decorator (`@add_tracing`) instruments your code, and the same trace data flows through every phase:

<Frame>
  <img className="block dark:hidden" src="https://mintcdn.com/dominodatalab-e871cec4/SlEjU-Wq-auPz-Gc/images/genai/agentic-dev-workflow-light.svg?fit=max&auto=format&n=SlEjU-Wq-auPz-Gc&q=85&s=f3fde2f026a0e3b17b78ffde0b96485b" alt="The agentic development workflow in Domino. What you build: an agent framework such as LangChain, Pydantic AI, or OpenAI feeds your agent logic (prompts, tools, memory, routing), which calls an LLM endpoint that is either an external API or Domino-hosted. The Domino Platform and Agents SDK underpin four phases that iterate: Develop in a Domino Workspace, Evaluate with Domino Jobs, Deploy through the Experiment Manager and the Apps flow, and Monitor in the Agent Dashboard." width="940" height="510" data-path="images/genai/agentic-dev-workflow-light.svg" />

  <img className="hidden dark:block" src="https://mintcdn.com/dominodatalab-e871cec4/SlEjU-Wq-auPz-Gc/images/genai/agentic-dev-workflow-dark.svg?fit=max&auto=format&n=SlEjU-Wq-auPz-Gc&q=85&s=c2a900094423a492278151d9cf29d33d" alt="The agentic development workflow in Domino. What you build: an agent framework such as LangChain, Pydantic AI, or OpenAI feeds your agent logic (prompts, tools, memory, routing), which calls an LLM endpoint that is either an external API or Domino-hosted. The Domino Platform and Agents SDK underpin four phases that iterate: Develop in a Domino Workspace, Evaluate with Domino Jobs, Deploy through the Experiment Manager and the Apps flow, and Monitor in the Agent Dashboard." width="940" height="510" data-path="images/genai/agentic-dev-workflow-dark.svg" />
</Frame>

<Steps>
  <Step title="Set up LLM access">
    Connect to an external LLM provider (OpenAI, Anthropic, Bedrock, or Azure OpenAI) or to a Domino-hosted endpoint, and store credentials as Domino environment variables. [Set up LLM access](/cloud/platform-capabilities/features/llms) covers both approaches.
  </Step>

  <Step title="Develop in a Workspace">
    Write your agent code using any framework and add `@add_tracing` with inline evaluators to instrument it. Then prepare test data for your agent configuration. See [Develop agentic systems](/cloud/platform-capabilities/features/agents/develop).
  </Step>

  <Step title="Evaluate as a Job">
    [Run your evaluation script as a Domino Job](/cloud/platform-capabilities/features/agents/develop#step-3-run-as-a-domino-job). Each Job creates an agent version in the Experiment Manager, capturing traces with evaluation scores for that configuration. Runs aggregate evaluation results across all traces.
  </Step>

  <Step title="Compare and deploy">
    In the [Experiment Manager](/cloud/platform-capabilities/features/agents/experiment), compare runs and individual traces within runs, then deploy from any agent version that originated from a Job. Domino tracks lineage between development and production, including the commit, the agent configuration, and the performance results.
  </Step>

  <Step title="Monitor in production">
    The same `@add_tracing` instrumentation captures live user interactions as traces in the [Agent Dashboard](/cloud/platform-capabilities/features/agents/monitor). Schedule evaluation Jobs to score production traces continuously and iterate when quality drops.
  </Step>
</Steps>

## Start from a working example

Clone one of these repositories to see the whole workflow running before you instrument your own code:

<Columns cols={3}>
  <Card title="simple_domino_agent" href="https://github.com/dominodatalab/simple_domino_agent">
    Minimal agent with tool calls, tracing, evaluation, and deployment.
  </Card>

  <Card title="rag-agent-demo" href="https://github.com/dominodatalab/rag-agent-demo">
    Retrieval-augmented generation (RAG) agent with ChromaDB, using the same Domino instrumentation patterns.
  </Card>

  <Card title="simple_agent_api_only" href="https://github.com/dominodatalab/simple_agent_api_only">
    REST API and agent-to-agent (A2A) example, with instructions for pairing it with a Domino-hosted agent registry and orchestrator.
  </Card>
</Columns>

## Related

* [Agentic AI overview](/cloud/platform-capabilities/features/agents/agentic-ai-overview): conceptual background on what makes a system agentic, and where a given design sits on the workflow-to-agent spectrum.
* [Set up LLM access](/cloud/platform-capabilities/features/llms): choose between an external provider and a model you host in Domino.
* [Publish Apps](/cloud/platform-capabilities/features/apps): the deployment path agents share with Apps.


## Related topics

- [Agents](/cloud/platform-capabilities/features/agents/index.md)
- [Size the data plane agent](/cloud/admin/architecture-and-deployment/sizing-the-infrastructure/size-data-plane-agent.md)
- [API reference for the Agents Python SDK](/6.3/reference/experiment-agent-sdk/python-sdk-agents.md)
- [Govern models, apps, agents, and files](/6.3/platform-capabilities/features/governance/work-with-bundles/govern-models-apps-files.md)