For the complete documentation index, see llms.txt. Markdown versions of all docs pages are available by appending .md to any docs URL.

Open the kagent dashboard, then read the agents, conversations, and Agent Substrate capacity that it reports.

The kagent UI is a read-and-write console for everything the controller knows about: the agents you defined, the conversations the agents hold, and the Agent Substrate capacity that those conversations run on. The kagent chart installs the UI alongside the controller, so a cluster that follows Install kagent already runs a UI instance.

Before you begin

1. Install kagent in your cluster.

2. Confirm that the UI service exists.

   kubectl get svc -n kagent kagent-ui

   Example output:

   NAME        TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
   kagent-ui   ClusterIP   10.96.174.203   <none>        8080/TCP   3m
   

Open the dashboard

The UI service is a ClusterIP by default, so it is reachable only from inside the cluster. Forward it to your machine with the kagent CLI or with kubectl. Both routes end at the same address, http://localhost:8082.

The dashboard opens on a summary of what the controller has loaded. A fresh installation reports no agents and no conversations, and already counts the model configuration and the Model Context ProtocolModel Context ProtocolAn open protocol for exposing tools and resources to a model. kagent reaches an MCP server through a RemoteMCPServer resource, and an AgentTemplate binds individual tools from it.Learn more (MCP) servers that the chart installed.

Explore the UI

The left menu groups the console by the resource each page reads, so the page you want follows from the resource you are asking about.

Start at the Agents page to review the agents and their backing pairs of AgentTempate and Harness resources. The page lists the derived pairs across its Agents, Templates, and Harnesses tabs.

Read a conversation

Opening an agent and sending a message creates an AgentInstanceAgentInstanceA running, conversational pairing of a Harness and an AgentTemplate. Unlike the two, it is not a Kubernetes resource: kagent's gRPC API creates it and its database tracks it.Learn more, which is one conversation scheduled onto a Substrate ActorActorThe sandboxed unit of compute, provided by Agent Substrate, that runs an AgentInstance's conversation loop. Every AgentInstance is backed by one.Learn more. The conversation view shows the transcript, the tool calls the agent made along the way, and the controls that branch the conversation.

Two controls under the transcript branch the conversation rather than continue it.

• Checkpoint pins the snapshot that the AgentInstance most recently suspended to, and records how far the transcript advanced. Agent Substrate does not collect a pinned snapshot, so the point stays available to return to. To understand how pinning works, and why a turn must be complete first, see Checkpoints.
• Fork creates a second AgentInstance from a checkpoint, continuing from the point that the checkpoint pinned. A forkForkA second AgentInstance created from a checkpoint, continuing the conversation from the point that the checkpoint pinned. A fork inherits the checkpoint's revision, so later edits to the AgentTemplate do not change what it runs, and new turns append only to the fork, leaving the original's history untouched.Learn more inherits the checkpoint’s RevisionRevisionThe compiled, immutable output of one Harness and AgentTemplate pairing, identified by a content digest. An AgentInstance runs the revision it was created from for its whole life, so editing either resource affects only instances created afterward., so later edits to the AgentTemplate do not change what it runs, and new turns append only to the fork. For the same operation over the gRPC API, see Fork the conversation into a second agent.

Check Agent Substrate capacity

The Substrate page shows whether there is capacity for an agent to run. It reads WorkerPools and ActorTemplates from Kubernetes, and live Actors and Worker assignments from the Agent Substrate API.

Read the page from the top tiles down.

A fresh installation reports one worker pool, no actor templates, and no actors, because nothing has created an agent yet. The Workers table still lists the pool’s worker as idle. That idle worker confirms that capacity is provisioned and waiting for the first agent.

Expose the UI outside the cluster

Port-forwarding suits local access and stops when you close the terminal. For a deployment that a team reaches, change how the chart publishes the service. Add any of the following values to the helm upgrade --install kagent command from Install kagent.

LoadBalancer service

To provision a cloud load balancer for the UI, set the service type.

ui:
  service:
    type: LoadBalancer

Then read the external address from the service.

kubectl get svc -n kagent kagent-ui

OpenShift route

On OpenShift clusters kagent creates an edge-terminated Route for the UI whenever the route.openshift.io/v1 API is present. The route is enabled by default through ui.route.enabled.

The default HAProxy timeout is raised to 120 minutes, because agent conversations hold long-lived streaming connections that a shorter timeout terminates mid-reply. To change it, set the annotation.

ui:
  openshiftRoute:
    annotations:
      haproxy.router.openshift.io/timeout: 60m

To front the UI with your own ingress instead, set ui.route.enabled: false to stop kagent creating the route.

Gateway API HTTPRoute

On a cluster that runs a Kubernetes Gateway API implementation such as kgateway, Istio, or Envoy Gateway, publish the UI through an HTTPRoute.

ui:
  httpRoute:
    enabled: true
    parentRefs:
      - name: my-gateway
        namespace: gateway-system
    hostnames:
      - kagent.example.com

The parentRefs field is required when enabled is true, and it must reference a Gateway that already exists. The HTTPRoute resource also requires the Gateway API custom resource definitions (gateway.networking.k8s.io/v1) in the cluster.

Next steps