kagent

Overview

kagent has built-in OpenTelemetry support for tracing and logging. By enabling these features and configuring an OpenTelemetry Collector, you can send all agent execution telemetry to Dash0, including LLM calls, tool executions, and agent decision flows.

This guide shows you how to deploy kagent on Kubernetes with OpenTelemetry tracing and logging enabled, forwarding all telemetry data to Dash0 for complete visibility into your AI agent operations.

Prerequisites

Before setting up kagent monitoring, ensure:

• Kubernetes cluster (1.27+)
• Helm 3.x installed
• API key for your LLM provider (Anthropic, OpenAI, Azure OpenAI, etc.)
• OpenTelemetry Collector deployed with OTLP receivers (gRPC on port 4317)

You'll need an OpenTelemetry Collector that accepts OTLP and exports to Dash0. Consider using:

• Dash0 operator for Kubernetes (recommended)
• OpenTelemetry Operator for Kubernetes

• Helm Chart for The OpenTelemetry Collector

Install kagent with OpenTelemetry

Step 1: Create kagent namespace and LLM provider secret

For other providers, see the kagent documentation on LLM providers.

Step 2: Create kagent values file

Create kagent-values.yaml with OpenTelemetry enabled:

Note: Update the endpoint to match your OpenTelemetry Collector service name and namespace.

Step 3: Install kagent

Verification

Access kagent UI

Open http://localhost:8080 to access the kagent dashboard.

View traces in Dash0

1. Navigate to your Dash0 account
2. Go to the Traces section
3. Filter by service.name=kagent* to see all kagent traces
4. You should see:
   • Agent execution traces
   • LLM API calls to your provider (Anthropic, OpenAI, etc.)
   • Tool execution spans
   • Multi-agent orchestration flows

Create an Observability Agent with Dash0 MCP

kagent agents can use Dash0's Model Context Protocol (MCP) server to query observability data directly. This enables agents to help with SRE tasks, troubleshooting, and performance analysis by accessing logs, traces, metrics, and service information.

Prerequisites

You'll need a Dash0 auth token for MCP access. While you can use your existing auth token, we recommend creating a dedicated token for MCP:

1. Go to Organization Settings > Auth Tokens
2. Create a new auth token with appropriate permissions:
   • Full access (*) - Recommended for full MCP functionality
   • Read-only (*:read) - For read-only access to observability data

Step 1: Deploy Dash0 MCP Server

Create dash0-mcp.yaml to configure the MCP connection:

Deploy the MCP server configuration:

Step 2: Create an Observability Agent

Create observability-agent.yaml that uses Dash0 MCP tools:

Deploy the observability agent:

Step 3: Interact with the Agent

Access the kagent UI at http://localhost:8080 and select the observability-agent. You can now ask questions like:

• "What services are running in my cluster?"
• "Show me recent errors in the kagent service"
• "What are the slowest spans in the last hour?"
• "Find correlated logs for failing requests"
• "What's the p95 latency for my API endpoints?"

The agent will use Dash0 MCP tools to query your observability data and provide insights. All agent interactions are traced and sent to Dash0, allowing you to see how the agent uses different tools to answer your questions.

References

• kagent Official Documentation
• kagent GitHub Repository
• kagent Observability Guide
• kagent LLM Providers
• OpenTelemetry Collector Documentation