How do I see OpenHands usage across my whole engineering team?

Rius shows OpenHands usage per developer when every developer sends conversations to one shared workspace and passes a user_id when creating the Conversation. The Users page then lists each developer with their traces, failed traces and cost. OpenHands needs no plugin, only three environment variables.

How it works

The OpenHands SDK already traces every conversation with OpenTelemetry. Three environment variables point that tracing at Rius, and each conversation arrives as one trace: the conversation, each agent step, and the model and tool calls inside it. Model calls carry their model, tokens, cache reads and writes, and cost. Costs are list-price estimates in US dollars.

The team view comes from two things:

• One workspace. A trace belongs to the workspace of the API key that sent it, so a shared workspace adds everyone’s conversations together.
• A user on every span. When you pass user_id to the Conversation, every span carries it, and Rius files the conversation under that developer on the Users page. The conversation id becomes the Rius session, so a multi-turn conversation groups together.

Conversations sent without a user_id land in the anonymous row on Users, so set it for every developer.

OpenHands conversations always send prompts and answers, and tool inputs and outputs. Everyone in the workspace can read them, so agree as a team which work goes through a traced setup.

Set it up

1. Pick one workspace for the team. A workspace admin invites teammates under Settings → Organization. In Settings → API keys, create a key with the Send telemetry scope. The key is shown once, so store it where your team keeps secrets.

2. Set the three variables where OpenHands runs. For an SDK script, that is the process environment. The OpenHands guide has the full setup and the details that make traces fail silently when one value is off.

export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=https://ingest.eu.console.rius-glassflow.com/v1/traces
export OTEL_EXPORTER_OTLP_TRACES_PROTOCOL=http/protobuf
export OTEL_EXPORTER_OTLP_TRACES_HEADERS="Authorization=Bearer%20ri_..."

3. Pass the developer as user_id. Set it where you create the Conversation, with a different value per developer. The example uses an email. Rius shows the value as given, so an opaque id works too.

conversation = Conversation(
    agent=agent,
    workspace=".",
    user_id="dev@example.com",
    observability_metadata={"agent.name": "fib-writer"},
)

4. Name the agent. The agent.name metadata above is the name the conversation is grouped under. Without it, Rius uses the script’s filename. Start the script from its own directory, or the full path ends up in the service column.

5. Run OpenHands the way your team runs it. In the local web app, the variables go in OH_AGENT_SERVER_ENV on the app container, not as -e OTEL_..., because each agent runs in its own sandbox. In OpenHands Enterprise, send traces to Rius by following the OpenHands guide, which covers the Helm and VM installs.

6. Read the result. Open the Users page, sort by Cost to see who drives spend, and open a developer to see their recent and failed conversations. Choose the time window you want to compare.

What you get

• One row per developer on the Users page, with traces, failed traces and cost for the window you select.
• A trace for each conversation, with every model call and tool call. A terminal command shows with its exit code, so you can go from a developer’s cost to the exact step.
• The OpenHands agents on the Agents page, with their failed traces, errors and cost.
• Alerts for the whole team. Tool Loop fires when the same tool is called with the same arguments three times in a row, and Consistent Error Pattern fires when the same error repeats across runs, such as a rotated model key. Attach a channel to get them in Slack, email or a webhook.
• The same workspace for your other coding agents. The Claude Code team guide shows each Claude Code developer by the email they sign in with, so both tools sit side by side on the Users page. The Coding agents guide covers the rest.

Two gaps affect cost per developer. Conversations from the OpenHands web app have no tokens or cost, because their model calls are streamed. SDK scripts using OpenAI Responses API models such as GPT-4.1 and GPT-5 also carry no token data. Claude and GPT-4o in SDK scripts come through in full.

When something else fits

• OpenHands Cloud cannot send to Rius, because Cloud agents take no custom environment variables. Run the OpenHands SDK or the local web app instead.
• If you need cost for every web-app conversation, use SDK scripts, which report tokens and cost for the models listed above.
• If each developer should sign in and be identified by their account rather than a value you pass, the Claude Code plugin does that with /rius:login. OpenHands has no sign-in step.

Related